type_traits.h revision 360660
1//===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file provides useful additions to the standard type_traits library. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_SUPPORT_TYPE_TRAITS_H 14#define LLVM_SUPPORT_TYPE_TRAITS_H 15 16#include "llvm/Support/Compiler.h" 17#include <type_traits> 18#include <utility> 19 20#ifndef __has_feature 21#define LLVM_DEFINED_HAS_FEATURE 22#define __has_feature(x) 0 23#endif 24 25namespace llvm { 26 27 28/// Metafunction that determines whether the given type is either an 29/// integral type or an enumeration type, including enum classes. 30/// 31/// Note that this accepts potentially more integral types than is_integral 32/// because it is based on being implicitly convertible to an integral type. 33/// Also note that enum classes aren't implicitly convertible to integral types, 34/// the value may therefore need to be explicitly converted before being used. 35template <typename T> class is_integral_or_enum { 36 using UnderlyingT = typename std::remove_reference<T>::type; 37 38public: 39 static const bool value = 40 !std::is_class<UnderlyingT>::value && // Filter conversion operators. 41 !std::is_pointer<UnderlyingT>::value && 42 !std::is_floating_point<UnderlyingT>::value && 43 (std::is_enum<UnderlyingT>::value || 44 std::is_convertible<UnderlyingT, unsigned long long>::value); 45}; 46 47/// If T is a pointer, just return it. If it is not, return T&. 48template<typename T, typename Enable = void> 49struct add_lvalue_reference_if_not_pointer { using type = T &; }; 50 51template <typename T> 52struct add_lvalue_reference_if_not_pointer< 53 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 54 using type = T; 55}; 56 57/// If T is a pointer to X, return a pointer to const X. If it is not, 58/// return const T. 59template<typename T, typename Enable = void> 60struct add_const_past_pointer { using type = const T; }; 61 62template <typename T> 63struct add_const_past_pointer< 64 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 65 using type = const typename std::remove_pointer<T>::type *; 66}; 67 68template <typename T, typename Enable = void> 69struct const_pointer_or_const_ref { 70 using type = const T &; 71}; 72template <typename T> 73struct const_pointer_or_const_ref< 74 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 75 using type = typename add_const_past_pointer<T>::type; 76}; 77 78namespace detail { 79/// Internal utility to detect trivial copy construction. 80template<typename T> union copy_construction_triviality_helper { 81 T t; 82 copy_construction_triviality_helper() = default; 83 copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default; 84 ~copy_construction_triviality_helper() = default; 85}; 86/// Internal utility to detect trivial move construction. 87template<typename T> union move_construction_triviality_helper { 88 T t; 89 move_construction_triviality_helper() = default; 90 move_construction_triviality_helper(move_construction_triviality_helper&&) = default; 91 ~move_construction_triviality_helper() = default; 92}; 93 94template<class T> 95union trivial_helper { 96 T t; 97}; 98 99} // end namespace detail 100 101/// An implementation of `std::is_trivially_copy_constructible` since we have 102/// users with STLs that don't yet include it. 103template <typename T> 104struct is_trivially_copy_constructible 105 : std::is_copy_constructible< 106 ::llvm::detail::copy_construction_triviality_helper<T>> {}; 107template <typename T> 108struct is_trivially_copy_constructible<T &> : std::true_type {}; 109template <typename T> 110struct is_trivially_copy_constructible<T &&> : std::false_type {}; 111 112/// An implementation of `std::is_trivially_move_constructible` since we have 113/// users with STLs that don't yet include it. 114template <typename T> 115struct is_trivially_move_constructible 116 : std::is_move_constructible< 117 ::llvm::detail::move_construction_triviality_helper<T>> {}; 118template <typename T> 119struct is_trivially_move_constructible<T &> : std::true_type {}; 120template <typename T> 121struct is_trivially_move_constructible<T &&> : std::true_type {}; 122 123 124template <typename T> 125struct is_copy_assignable { 126 template<class F> 127 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{}); 128 static std::false_type get(...); 129 static constexpr bool value = decltype(get((T*)nullptr))::value; 130}; 131 132template <typename T> 133struct is_move_assignable { 134 template<class F> 135 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{}); 136 static std::false_type get(...); 137 static constexpr bool value = decltype(get((T*)nullptr))::value; 138}; 139 140 141// An implementation of `std::is_trivially_copyable` since STL version 142// is not equally supported by all compilers, especially GCC 4.9. 143// Uniform implementation of this trait is important for ABI compatibility 144// as it has an impact on SmallVector's ABI (among others). 145template <typename T> 146class is_trivially_copyable { 147 148 // copy constructors 149 static constexpr bool has_trivial_copy_constructor = 150 std::is_copy_constructible<detail::trivial_helper<T>>::value; 151 static constexpr bool has_deleted_copy_constructor = 152 !std::is_copy_constructible<T>::value; 153 154 // move constructors 155 static constexpr bool has_trivial_move_constructor = 156 std::is_move_constructible<detail::trivial_helper<T>>::value; 157 static constexpr bool has_deleted_move_constructor = 158 !std::is_move_constructible<T>::value; 159 160 // copy assign 161 static constexpr bool has_trivial_copy_assign = 162 is_copy_assignable<detail::trivial_helper<T>>::value; 163 static constexpr bool has_deleted_copy_assign = 164 !is_copy_assignable<T>::value; 165 166 // move assign 167 static constexpr bool has_trivial_move_assign = 168 is_move_assignable<detail::trivial_helper<T>>::value; 169 static constexpr bool has_deleted_move_assign = 170 !is_move_assignable<T>::value; 171 172 // destructor 173 static constexpr bool has_trivial_destructor = 174 std::is_destructible<detail::trivial_helper<T>>::value; 175 176 public: 177 178 static constexpr bool value = 179 has_trivial_destructor && 180 (has_deleted_move_assign || has_trivial_move_assign) && 181 (has_deleted_move_constructor || has_trivial_move_constructor) && 182 (has_deleted_copy_assign || has_trivial_copy_assign) && 183 (has_deleted_copy_constructor || has_trivial_copy_constructor); 184 185#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE 186 static_assert(value == std::is_trivially_copyable<T>::value, 187 "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable"); 188#endif 189}; 190template <typename T> 191class is_trivially_copyable<T*> : public std::true_type { 192}; 193 194 195} // end namespace llvm 196 197// If the compiler supports detecting whether a class is final, define 198// an LLVM_IS_FINAL macro. If it cannot be defined properly, this 199// macro will be left undefined. 200#if __cplusplus >= 201402L || defined(_MSC_VER) 201#define LLVM_IS_FINAL(Ty) std::is_final<Ty>() 202#elif __has_feature(is_final) || LLVM_GNUC_PREREQ(4, 7, 0) 203#define LLVM_IS_FINAL(Ty) __is_final(Ty) 204#endif 205 206#ifdef LLVM_DEFINED_HAS_FEATURE 207#undef __has_feature 208#endif 209 210#endif // LLVM_SUPPORT_TYPE_TRAITS_H 211