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