1//===----------------------------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is dual licensed under the MIT and the University of Illinois Open 6// Source Licenses. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10// type_traits 11 12// is_convertible 13 14#include <type_traits> 15#include "test_macros.h" 16 17template <class T, class U> 18void test_is_convertible() 19{ 20 static_assert((std::is_convertible<T, U>::value), ""); 21 static_assert((std::is_convertible<const T, U>::value), ""); 22 static_assert((std::is_convertible<T, const U>::value), ""); 23 static_assert((std::is_convertible<const T, const U>::value), ""); 24#if TEST_STD_VER > 14 25 static_assert((std::is_convertible_v<T, U>), ""); 26 static_assert((std::is_convertible_v<const T, U>), ""); 27 static_assert((std::is_convertible_v<T, const U>), ""); 28 static_assert((std::is_convertible_v<const T, const U>), ""); 29#endif 30} 31 32template <class T, class U> 33void test_is_not_convertible() 34{ 35 static_assert((!std::is_convertible<T, U>::value), ""); 36 static_assert((!std::is_convertible<const T, U>::value), ""); 37 static_assert((!std::is_convertible<T, const U>::value), ""); 38 static_assert((!std::is_convertible<const T, const U>::value), ""); 39#if TEST_STD_VER > 14 40 static_assert((!std::is_convertible_v<T, U>), ""); 41 static_assert((!std::is_convertible_v<const T, U>), ""); 42 static_assert((!std::is_convertible_v<T, const U>), ""); 43 static_assert((!std::is_convertible_v<const T, const U>), ""); 44#endif 45} 46 47typedef void Function(); 48typedef void ConstFunction() const; 49typedef char Array[1]; 50 51struct StringType { 52 StringType(const char*) {} 53}; 54 55class NonCopyable { 56 NonCopyable(NonCopyable&); 57}; 58 59template <typename T> 60class CannotInstantiate { 61 enum { X = T::ThisExpressionWillBlowUp }; 62}; 63 64int main() 65{ 66 // void 67 test_is_convertible<void,void> (); 68 test_is_not_convertible<void,Function> (); 69 test_is_not_convertible<void,Function&> (); 70 test_is_not_convertible<void,Function*> (); 71 test_is_not_convertible<void,Array> (); 72 test_is_not_convertible<void,Array&> (); 73 test_is_not_convertible<void,char> (); 74 test_is_not_convertible<void,char&> (); 75 test_is_not_convertible<void,char*> (); 76 test_is_not_convertible<char, void>(); 77 78 // Function 79 test_is_not_convertible<Function, void> (); 80 test_is_not_convertible<Function, Function> (); 81 test_is_convertible<Function, Function&> (); 82 test_is_convertible<Function, Function*> (); 83 test_is_convertible<Function, Function*const> (); 84 85#if TEST_STD_VER >= 11 86 static_assert(( std::is_convertible<Function, Function&&>::value), ""); 87#endif 88 89 test_is_not_convertible<Function, Array> (); 90 test_is_not_convertible<Function, Array&> (); 91 test_is_not_convertible<Function, char> (); 92 test_is_not_convertible<Function, char&> (); 93 test_is_not_convertible<Function, char*> (); 94 95 // Function& 96 test_is_not_convertible<Function&, void> (); 97 test_is_not_convertible<Function&, Function> (); 98 test_is_convertible<Function&, Function&> (); 99 100 test_is_convertible<Function&, Function*> (); 101 test_is_not_convertible<Function&, Array> (); 102 test_is_not_convertible<Function&, Array&> (); 103 test_is_not_convertible<Function&, char> (); 104 test_is_not_convertible<Function&, char&> (); 105 test_is_not_convertible<Function&, char*> (); 106 107 // Function* 108 test_is_not_convertible<Function*, void> (); 109 test_is_not_convertible<Function*, Function> (); 110 test_is_not_convertible<Function*, Function&> (); 111 test_is_convertible<Function*, Function*> (); 112 113 test_is_not_convertible<Function*, Array> (); 114 test_is_not_convertible<Function*, Array&> (); 115 test_is_not_convertible<Function*, char> (); 116 test_is_not_convertible<Function*, char&> (); 117 test_is_not_convertible<Function*, char*> (); 118 119 // Non-referencable function type 120 static_assert((!std::is_convertible<ConstFunction, Function>::value), ""); 121 static_assert((!std::is_convertible<ConstFunction, Function*>::value), ""); 122 static_assert((!std::is_convertible<ConstFunction, Function&>::value), ""); 123 static_assert((!std::is_convertible<ConstFunction, Function>::value), ""); 124 static_assert((!std::is_convertible<Function*, ConstFunction>::value), ""); 125 static_assert((!std::is_convertible<Function&, ConstFunction>::value), ""); 126 static_assert((!std::is_convertible<ConstFunction, ConstFunction>::value), ""); 127 static_assert((!std::is_convertible<ConstFunction, void>::value), ""); 128 129 // Array 130 test_is_not_convertible<Array, void> (); 131 test_is_not_convertible<Array, Function> (); 132 test_is_not_convertible<Array, Function&> (); 133 test_is_not_convertible<Array, Function*> (); 134 test_is_not_convertible<Array, Array> (); 135 136 static_assert((!std::is_convertible<Array, Array&>::value), ""); 137 static_assert(( std::is_convertible<Array, const Array&>::value), ""); 138 static_assert((!std::is_convertible<Array, const volatile Array&>::value), ""); 139 140 static_assert((!std::is_convertible<const Array, Array&>::value), ""); 141 static_assert(( std::is_convertible<const Array, const Array&>::value), ""); 142 static_assert((!std::is_convertible<Array, volatile Array&>::value), ""); 143 static_assert((!std::is_convertible<Array, const volatile Array&>::value), ""); 144 145#if TEST_STD_VER >= 11 146 static_assert(( std::is_convertible<Array, Array&&>::value), ""); 147 static_assert(( std::is_convertible<Array, const Array&&>::value), ""); 148 static_assert(( std::is_convertible<Array, volatile Array&&>::value), ""); 149 static_assert(( std::is_convertible<Array, const volatile Array&&>::value), ""); 150 static_assert(( std::is_convertible<const Array, const Array&&>::value), ""); 151 static_assert((!std::is_convertible<Array&, Array&&>::value), ""); 152 static_assert((!std::is_convertible<Array&&, Array&>::value), ""); 153#endif 154 155 test_is_not_convertible<Array, char> (); 156 test_is_not_convertible<Array, char&> (); 157 158 static_assert(( std::is_convertible<Array, char*>::value), ""); 159 static_assert(( std::is_convertible<Array, const char*>::value), ""); 160 static_assert(( std::is_convertible<Array, char* const>::value), ""); 161 static_assert(( std::is_convertible<Array, char* const volatile>::value), ""); 162 163 static_assert((!std::is_convertible<const Array, char*>::value), ""); 164 static_assert(( std::is_convertible<const Array, const char*>::value), ""); 165 166 static_assert((!std::is_convertible<char[42][42], char*>::value), ""); 167 static_assert((!std::is_convertible<char[][1], char*>::value), ""); 168 169 // Array& 170 test_is_not_convertible<Array&, void> (); 171 test_is_not_convertible<Array&, Function> (); 172 test_is_not_convertible<Array&, Function&> (); 173 test_is_not_convertible<Array&, Function*> (); 174 test_is_not_convertible<Array&, Array> (); 175 176 static_assert(( std::is_convertible<Array&, Array&>::value), ""); 177 static_assert(( std::is_convertible<Array&, const Array&>::value), ""); 178 static_assert((!std::is_convertible<const Array&, Array&>::value), ""); 179 static_assert(( std::is_convertible<const Array&, const Array&>::value), ""); 180 181 test_is_not_convertible<Array&, char> (); 182 test_is_not_convertible<Array&, char&> (); 183 184 static_assert(( std::is_convertible<Array&, char*>::value), ""); 185 static_assert(( std::is_convertible<Array&, const char*>::value), ""); 186 static_assert((!std::is_convertible<const Array&, char*>::value), ""); 187 static_assert(( std::is_convertible<const Array&, const char*>::value), ""); 188 189 static_assert((std::is_convertible<Array, StringType>::value), ""); 190 static_assert((std::is_convertible<char(&)[], StringType>::value), ""); 191 192 // char 193 test_is_not_convertible<char, void> (); 194 test_is_not_convertible<char, Function> (); 195 test_is_not_convertible<char, Function&> (); 196 test_is_not_convertible<char, Function*> (); 197 test_is_not_convertible<char, Array> (); 198 test_is_not_convertible<char, Array&> (); 199 200 test_is_convertible<char, char> (); 201 202 static_assert((!std::is_convertible<char, char&>::value), ""); 203 static_assert(( std::is_convertible<char, const char&>::value), ""); 204 static_assert((!std::is_convertible<const char, char&>::value), ""); 205 static_assert(( std::is_convertible<const char, const char&>::value), ""); 206 207 test_is_not_convertible<char, char*> (); 208 209 // char& 210 test_is_not_convertible<char&, void> (); 211 test_is_not_convertible<char&, Function> (); 212 test_is_not_convertible<char&, Function&> (); 213 test_is_not_convertible<char&, Function*> (); 214 test_is_not_convertible<char&, Array> (); 215 test_is_not_convertible<char&, Array&> (); 216 217 test_is_convertible<char&, char> (); 218 219 static_assert(( std::is_convertible<char&, char&>::value), ""); 220 static_assert(( std::is_convertible<char&, const char&>::value), ""); 221 static_assert((!std::is_convertible<const char&, char&>::value), ""); 222 static_assert(( std::is_convertible<const char&, const char&>::value), ""); 223 224 test_is_not_convertible<char&, char*> (); 225 226 // char* 227 test_is_not_convertible<char*, void> (); 228 test_is_not_convertible<char*, Function> (); 229 test_is_not_convertible<char*, Function&> (); 230 test_is_not_convertible<char*, Function*> (); 231 test_is_not_convertible<char*, Array> (); 232 test_is_not_convertible<char*, Array&> (); 233 234 test_is_not_convertible<char*, char> (); 235 test_is_not_convertible<char*, char&> (); 236 237 static_assert(( std::is_convertible<char*, char*>::value), ""); 238 static_assert(( std::is_convertible<char*, const char*>::value), ""); 239 static_assert((!std::is_convertible<const char*, char*>::value), ""); 240 static_assert(( std::is_convertible<const char*, const char*>::value), ""); 241 242 // NonCopyable 243 static_assert((std::is_convertible<NonCopyable&, NonCopyable&>::value), ""); 244 static_assert((std::is_convertible<NonCopyable&, const NonCopyable&>::value), ""); 245 static_assert((std::is_convertible<NonCopyable&, const volatile NonCopyable&>::value), ""); 246 static_assert((std::is_convertible<NonCopyable&, volatile NonCopyable&>::value), ""); 247 static_assert((std::is_convertible<const NonCopyable&, const NonCopyable&>::value), ""); 248 static_assert((std::is_convertible<const NonCopyable&, const volatile NonCopyable&>::value), ""); 249 static_assert((std::is_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value), ""); 250 static_assert((std::is_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value), ""); 251 static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), ""); 252// This test requires Access control SFINAE which we only have in C++11 or when 253// we are using the compiler builtin for is_convertible. 254#if TEST_STD_VER >= 11 || !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) 255 test_is_not_convertible<NonCopyable&, NonCopyable>(); 256#endif 257 258 // Ensure that CannotInstantiate is not instantiated by is_convertible when it is not needed. 259 // For example CannotInstantiate is instatiated as a part of ADL lookup for arguments of type CannotInstantiate*. 260 static_assert((std::is_convertible<CannotInstantiate<int>*, CannotInstantiate<int>*>::value), ""); 261} 262