[libcxx] adds concept `std::convertible_to`

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

[miscco]

I left mostly some nits with respect to readability. Great job

libcxx/include/concepts

199

The standard depicts those as From and To and in the type trait it is also _From and _To.

So lets be consistent and use the same naming

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

22

Does that compile without the second string argument? It is used everywhere else int eh test suite even if its empty

147

Should we move this fundamental checks that do not rely on any Modifier to their own function? These are the most common ones so as a reader it would be easier to check them in isolation and then have the specialized function do the tricky stuff

219

I am wondering whether it is cleaner to define those basic types above and for the constructors and then create all the others by inheritance, e.g:

struct ImplicitlyConstructibleAndConvertible : public ImplicitelyConstructible, public Convertible {
{
    using ImplicitelyConstructible::ImplicitelyConstructible;
};

262

Newlines missing from here

[cjdb]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

22

C++17 makes this possible. I don't think the empty string literal is necessary, since this is a test for C++20.

147

Yes. Do you mean fold them into a function and then call said function here, or have a references namespace?

219

I was planning to do derived cases in a separate namespace to keep what's being tested very explicit. Do you think I'm being too granular?

[miscco]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

147

Given that the namespace is "Fundamentals" I would move it into its own function and test it against some basic types such as int, struct A{};, enum class etc

219

But you are doing essentially derived cases here. ImplicitlyConstructibleAndConvertible is a conjunction of ImplicitelyConstructible and ImplicitelyConvertible

Note that this is just a question whether it is actually easier to read rather than a correctness issue.

[zoecarver]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

All tests should include "test_macros.h"

[miscco]

Ping @cjdb I knowit has been a while but are you still planning on working on this?

[cjdb]

In D77961#2286065, @miscco wrote:

Ping @cjdb I knowit has been a while but are you still planning on working on this?

@miscco I don't mind handing this PR off to you if you're wanting to champion the remaining bits.

[miscco]

@cjdb This was just a ping to see whether you are still interested.

If you say you have no time / interest I might carve some time out in the near future but it would take a while

[cjdb]

No change to one from ~10 minutes ago; trying to activate CI.

[cjdb]

Activates CI

[cjdb]

CI update

[cjdb]

fixes CI issues

[ldionne]

This looks pretty good to me except the duplication of implementations when intrinsics are available.

More generally, have we looked into the MSVC tests for concepts? Would it make sense to import them here too or at least make sure we have the same coverage?

libcxx/include/concepts

165

As discussed offline, I would rather we use the same implementation all the time to simplify things. Let's not duplicate each implementation based on whether we can use intrinsics or not. The type traits themselves use the intrinsics, I think that's sufficient.

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

Technically, only include test_macros.h if you need something defined in it. The one header we always want to include is the one with nasty macros in it, but it's automatically included by the test suite harness.

[zoecarver]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

I disagree, I think all tests should include this header, regardless of whether or not they actually use it. The most important reason is that sometimes someone will update a test in a few years, and add a condition with TEST_STD_VER, not realizing that TEST_STD_VER is undefined. For example, before 7fc6a55688c816f5fc1a5481ae7af25be7500356 landed, over 300 tests used TEST_STD_VER without importing test_macros.h (not to mention the 3000 others that didn't include test_macros.h without references to that macro). This means that some parts of 300 tests were silently and unintentionally not being tested.

A less compelling reason that we might want all tests to include this header is to allow portability and more complicated nasty macro testing. For example, I think some people use this test suite without lit, meaning nasty macros won't work for them. Or maybe they don't have a compiler feature that we rely on. I think having an access point into all of the tests can be super benifitial in these cases.

[cjdb]

More generally, have we looked into the MSVC tests for concepts? Would it make sense to import them here too or at least make sure we have the same coverage?

From what I've seen, MSVC seems to have one monolithic file for all the concepts, so I think there are two options for us to choose from if we want to include them:

1. Wait till all of [concepts] is implemented, then add the MSVC test file at the root.
2. Split the monolithic file up so it fits in with all of the libc++ tests.

The advantage of approach (1) is that it's fast, and MSVC STL contributors can painlessly update our copy of the test file whenever theirs is also updated.
However, it's a monolithic test suite, and I'm not really keen on that: I prefer my tests to be more fine-grained, but this is more work, meaning we'd lose the convenience of getting MSVC STL updates almost for free.

Which do you prefer?

[ldionne]

In D77961#2552269, @cjdb wrote:

More generally, have we looked into the MSVC tests for concepts? Would it make sense to import them here too or at least make sure we have the same coverage?

From what I've seen, MSVC seems to have one monolithic file for all the concepts, so I think there are two options for us to choose from if we want to include them:

1. Wait till all of [concepts] is implemented, then add the MSVC test file at the root.
2. Split the monolithic file up so it fits in with all of the libc++ tests.

The advantage of approach (1) is that it's fast, and MSVC STL contributors can painlessly update our copy of the test file whenever theirs is also updated.
However, it's a monolithic test suite, and I'm not really keen on that: I prefer my tests to be more fine-grained, but this is more work, meaning we'd lose the convenience of getting MSVC STL updates almost for free.

Which do you prefer?

I think we could do (1). In the meantime, let's try to make sure we have good test coverage by ourselves (as you did here).

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

Don't we get a warning turned into an error for using #if TEST_STD_VER > XX if TEST_STD_VER isn't defined? That would be my expectation.

I don't think I follow the logic of the argument you make, because in the same spirit, we should always be including all other headers that define any macro to make sure we don't use macros when they're undefined (and have things behave unexpectedly for hard to understand reasons). I really think it's reasonable to not include test_macros.h when it's not needed: it makes the test suite more minimal. I think I fixed the issue of silently using an undefined macro when I enabled more warnings by default last year during my work on Lit, but I could be wrong.

[cjdb]

removes \#ifdef selection

[cjdb]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

std::convertible_to is a blocker for other concepts (e.g. move_constructible, common_reference_with, etc.), so I'd like to get it in ASAP.
Is it possible for this to be merged while you debate the need for including test_macros.h? I won't include it by default, but once you've reached consensus, I don't mind going back and adding it to all the concepts in one fell swoop (which I'll need to do for the already merged concepts anyway).

[ldionne]

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

14

It was never my intention to block you on adding or not adding that include :-).

[cjdb]

renames test file

libcxx/include/concepts

 // [concept.same]
 
 template<class _Tp, class _Up>
 concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
 
 template<class _Tp, class _Up>
 concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
 
+// [concept.convertible]
+
+#ifdef __clang__
+template<class _From, class _To>
+concept convertible_to =
+  __is_convertible_to(_From, _To) &&
+  requires(add_rvalue_reference_t<_From> (&__f)()) {
+    static_cast<_To>(__f());
+  };
+#else
+template<class _From, class _To>
+concept convertible_to =
+  _VSTD::is_convertible_v<_From, _To> &&
+  requires(add_rvalue_reference_t<_From> (&__f)()) {
+    static_cast<_To>(__f());
+  };
+#endif // __clang__
+
 // [concept.destructible]
 
 template<class _Tp>
 concept destructible = _VSTD::is_nothrow_destructible_v<_Tp>;
 
 // [concept.constructible]
 template<class _Tp, class... _Args>
 concept constructible_from =
     destructible<_Tp> && _VSTD::is_constructible_v<_Tp, _Args...>;
 
 // [concept.default.init]
 
 template<class _Tp>
 concept __default_initializable = requires { ::new _Tp; };
 
 template<class _Tp>
 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
-
 #endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/lang/convertible_to.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class From, class To>
+// concept convertible_to;
+
+#include <concepts>
+#include <type_traits>
+
+namespace {
+enum ClassicEnum { a, b };
+enum class ScopedEnum { x, y };
+struct Empty {};
+using nullptr_t = decltype(nullptr);
+
+template <class T, class U>
+void CheckConvertibleTo() {
+  static_assert(std::convertible_to<T, U>);
+  static_assert(std::convertible_to<const T, U>);
+  static_assert(std::convertible_to<T, const U>);
+  static_assert(std::convertible_to<const T, const U>);
+}
+
+template <class T, class U>
+void CheckNotConvertibleTo() {
+  static_assert(!std::convertible_to<T, U>);
+  static_assert(!std::convertible_to<const T, U>);
+  static_assert(!std::convertible_to<T, const U>);
+  static_assert(!std::convertible_to<const T, const U>);
+}
+
+template <class T, class U>
+void CheckIsConvertibleButNotConvertibleTo() {
+  // Sanity check T is either implicitly xor explicitly convertible to U.
+  static_assert(std::is_convertible_v<T, U>);
+  static_assert(std::is_convertible_v<const T, U>);
+  static_assert(std::is_convertible_v<T, const U>);
+  static_assert(std::is_convertible_v<const T, const U>);
+  CheckNotConvertibleTo<T, U>();
+}
+
+// Tests that should objectively return false (except for bool and nullptr_t)
+template <class T>
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<T, void>();
+  CheckNotConvertibleTo<T, nullptr_t>();
+  CheckNotConvertibleTo<T, T*>();
+  CheckNotConvertibleTo<T, T Empty::*>();
+  CheckNotConvertibleTo<T, T (Empty::*)()>();
+  CheckNotConvertibleTo<T, T[sizeof(T)]>();
+  CheckNotConvertibleTo<T, T (*)()>();
+  CheckNotConvertibleTo<T, T (&)()>();
+  CheckNotConvertibleTo<T, T(&&)()>();
+}
+
+template <std::same_as<bool> >
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<bool, void>();
+  CheckNotConvertibleTo<bool, nullptr_t>();
+  CheckConvertibleTo<bool Empty::*, bool>();
+  CheckConvertibleTo<bool (Empty::*)(), bool>();
+  CheckConvertibleTo<bool[2], bool>();
+  CheckConvertibleTo<bool (*)(), bool>();
+  CheckConvertibleTo<bool (&)(), bool>();
+  CheckConvertibleTo<bool(&&)(), bool>();
+}
+
+template <std::same_as<nullptr_t> >
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<nullptr_t, void>();
+  CheckConvertibleTo<nullptr_t, nullptr_t>();
+  CheckConvertibleTo<nullptr_t, void*>();
+  CheckConvertibleTo<nullptr_t, int Empty::*>();
+  CheckConvertibleTo<nullptr_t, void (Empty::*)()>();
+  CheckNotConvertibleTo<nullptr_t, int[2]>();
+  CheckConvertibleTo<nullptr_t, void (*)()>();
+  CheckNotConvertibleTo<nullptr_t, void (&)()>();
+  CheckNotConvertibleTo<nullptr_t, void(&&)()>();
+}
+} // namespace
+
+using Function = void();
+using NoexceptFunction = void() noexcept;
+using ConstFunction = void() const;
+using Array = char[1];
+
+struct StringType {
+  StringType(const char*) {}
+};
+
+class NonCopyable {
+  NonCopyable(NonCopyable&);
+};
+
+template <typename T>
+class CannotInstantiate {
+  enum { X = T::ThisExpressionWillBlowUp };
+};
+
+struct abstract {
+  virtual int f() = 0;
+};
+
+struct ExplicitlyConvertible;
+struct ImplicitlyConvertible;
+
+struct ExplicitlyConstructible {
+  explicit ExplicitlyConstructible(int);
+  explicit ExplicitlyConstructible(ExplicitlyConvertible);
+  explicit ExplicitlyConstructible(ImplicitlyConvertible) = delete;
+};
+
+struct ExplicitlyConvertible {
+  explicit operator ExplicitlyConstructible() const {
+    return ExplicitlyConstructible(0);
+  }
+};
+
+struct ImplicitlyConstructible;
+
+struct ImplicitlyConvertible {
+  operator ExplicitlyConstructible() const;
+  operator ImplicitlyConstructible() const = delete;
+};
+
+struct ImplicitlyConstructible {
+  ImplicitlyConstructible(ImplicitlyConvertible);
+};
+
+int main(int, char**) {
+  // void
+  CheckConvertibleTo<void, void>();
+  CheckNotConvertibleTo<void, Function>();
+  CheckNotConvertibleTo<void, Function&>();
+  CheckNotConvertibleTo<void, Function*>();
+  CheckNotConvertibleTo<void, NoexceptFunction>();
+  CheckNotConvertibleTo<void, NoexceptFunction&>();
+  CheckNotConvertibleTo<void, NoexceptFunction*>();
+  CheckNotConvertibleTo<void, Array>();
+  CheckNotConvertibleTo<void, Array&>();
+  CheckNotConvertibleTo<void, char>();
+  CheckNotConvertibleTo<void, char&>();
+  CheckNotConvertibleTo<void, char*>();
+  CheckNotConvertibleTo<char, void>();
+
+  // Function
+  CheckNotConvertibleTo<Function, void>();
+  CheckNotConvertibleTo<Function, Function>();
+  CheckNotConvertibleTo<Function, NoexceptFunction>();
+  CheckNotConvertibleTo<Function, NoexceptFunction&>();
+  CheckNotConvertibleTo<Function, NoexceptFunction*>();
+  CheckNotConvertibleTo<Function, NoexceptFunction* const>();
+  CheckConvertibleTo<Function, Function&>();
+  CheckConvertibleTo<Function, Function*>();
+  CheckConvertibleTo<Function, Function* const>();
+
+  static_assert(std::convertible_to<Function, Function&&>);
+  static_assert(!std::convertible_to<Function, NoexceptFunction&&>);
+
+  CheckNotConvertibleTo<Function, Array>();
+  CheckNotConvertibleTo<Function, Array&>();
+  CheckNotConvertibleTo<Function, char>();
+  CheckNotConvertibleTo<Function, char&>();
+  CheckNotConvertibleTo<Function, char*>();
+
+  // Function&
+  CheckNotConvertibleTo<Function&, void>();
+  CheckNotConvertibleTo<Function&, Function>();
+  CheckConvertibleTo<Function&, Function&>();
+
+  CheckConvertibleTo<Function&, Function*>();
+  CheckNotConvertibleTo<Function&, Array>();
+  CheckNotConvertibleTo<Function&, Array&>();
+  CheckNotConvertibleTo<Function&, char>();
+  CheckNotConvertibleTo<Function&, char&>();
+  CheckNotConvertibleTo<Function&, char*>();
+
+  // Function*
+  CheckNotConvertibleTo<Function*, void>();
+  CheckNotConvertibleTo<Function*, Function>();
+  CheckNotConvertibleTo<Function*, Function&>();
+  CheckConvertibleTo<Function*, Function*>();
+
+  CheckNotConvertibleTo<Function*, Array>();
+  CheckNotConvertibleTo<Function*, Array&>();
+  CheckNotConvertibleTo<Function*, char>();
+  CheckNotConvertibleTo<Function*, char&>();
+  CheckNotConvertibleTo<Function*, char*>();
+
+  // Non-referencable function type
+  static_assert(!std::convertible_to<ConstFunction, Function>);
+  static_assert(!std::convertible_to<ConstFunction, Function*>);
+  static_assert(!std::convertible_to<ConstFunction, Function&>);
+  static_assert(!std::convertible_to<ConstFunction, Function&&>);
+  static_assert(!std::convertible_to<Function*, ConstFunction>);
+  static_assert(!std::convertible_to<Function&, ConstFunction>);
+  static_assert(!std::convertible_to<ConstFunction, ConstFunction>);
+  static_assert(!std::convertible_to<ConstFunction, void>);
+
+  // NoexceptFunction
+  CheckNotConvertibleTo<NoexceptFunction, void>();
+  CheckNotConvertibleTo<NoexceptFunction, Function>();
+  CheckNotConvertibleTo<NoexceptFunction, NoexceptFunction>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction&>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction*>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction* const>();
+  CheckConvertibleTo<NoexceptFunction, Function&>();
+  CheckConvertibleTo<NoexceptFunction, Function*>();
+  CheckConvertibleTo<NoexceptFunction, Function* const>();
+
+  static_assert(std::convertible_to<NoexceptFunction, Function&&>);
+  static_assert(std::convertible_to<NoexceptFunction, NoexceptFunction&&>);
+
+  CheckNotConvertibleTo<NoexceptFunction, Array>();
+  CheckNotConvertibleTo<NoexceptFunction, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction, char>();
+  CheckNotConvertibleTo<NoexceptFunction, char&>();
+  CheckNotConvertibleTo<NoexceptFunction, char*>();
+
+  // NoexceptFunction&
+  CheckNotConvertibleTo<NoexceptFunction&, void>();
+  CheckNotConvertibleTo<NoexceptFunction&, Function>();
+  CheckNotConvertibleTo<NoexceptFunction&, NoexceptFunction>();
+  CheckConvertibleTo<NoexceptFunction&, Function&>();
+  CheckConvertibleTo<NoexceptFunction&, NoexceptFunction&>();
+
+  CheckConvertibleTo<NoexceptFunction&, Function*>();
+  CheckConvertibleTo<NoexceptFunction&, NoexceptFunction*>();
+  CheckNotConvertibleTo<NoexceptFunction&, Array>();
+  CheckNotConvertibleTo<NoexceptFunction&, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction&, char>();
+  CheckNotConvertibleTo<NoexceptFunction&, char&>();
+  CheckNotConvertibleTo<NoexceptFunction&, char*>();
+
+  // NoexceptFunction*
+  CheckNotConvertibleTo<NoexceptFunction*, void>();
+  CheckNotConvertibleTo<NoexceptFunction*, Function>();
+  CheckNotConvertibleTo<NoexceptFunction*, Function&>();
+  CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction>();
+  CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction&>();
+  CheckConvertibleTo<NoexceptFunction*, Function*>();
+  CheckConvertibleTo<NoexceptFunction*, NoexceptFunction*>();
+
+  CheckNotConvertibleTo<NoexceptFunction*, Array>();
+  CheckNotConvertibleTo<NoexceptFunction*, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction*, char>();
+  CheckNotConvertibleTo<NoexceptFunction*, char&>();
+  CheckNotConvertibleTo<NoexceptFunction*, char*>();
+
+  // Array
+  CheckNotConvertibleTo<Array, void>();
+  CheckNotConvertibleTo<Array, Function>();
+  CheckNotConvertibleTo<Array, Function&>();
+  CheckNotConvertibleTo<Array, Function*>();
+  CheckNotConvertibleTo<Array, NoexceptFunction>();
+  CheckNotConvertibleTo<Array, NoexceptFunction&>();
+  CheckNotConvertibleTo<Array, NoexceptFunction*>();
+  CheckNotConvertibleTo<Array, Array>();
+
+  static_assert(!std::convertible_to<Array, Array&>);
+  static_assert(std::convertible_to<Array, const Array&>);
+  static_assert(!std::convertible_to<Array, const volatile Array&>);
+
+  static_assert(!std::convertible_to<const Array, Array&>);
+  static_assert(std::convertible_to<const Array, const Array&>);
+  static_assert(!std::convertible_to<Array, volatile Array&>);
+  static_assert(!std::convertible_to<Array, const volatile Array&>);
+
+  static_assert(std::convertible_to<Array, Array&&>);
+  static_assert(std::convertible_to<Array, const Array&&>);
+  static_assert(std::convertible_to<Array, volatile Array&&>);
+  static_assert(std::convertible_to<Array, const volatile Array&&>);
+  static_assert(std::convertible_to<const Array, const Array&&>);
+  static_assert(!std::convertible_to<Array&, Array&&>);
+  static_assert(!std::convertible_to<Array&&, Array&>);
+
+  CheckNotConvertibleTo<Array, char>();
+  CheckNotConvertibleTo<Array, char&>();
+
+  static_assert(std::convertible_to<Array, char*>);
+  static_assert(std::convertible_to<Array, const char*>);
+  static_assert(std::convertible_to<Array, char* const>);
+  static_assert(std::convertible_to<Array, char* const volatile>);
+
+  static_assert(!std::convertible_to<const Array, char*>);
+  static_assert(std::convertible_to<const Array, const char*>);
+
+  static_assert(!std::convertible_to<char[42][42], char*>);
+  static_assert(!std::convertible_to<char[][1], char*>);
+
+  // Array&
+  CheckNotConvertibleTo<Array&, void>();
+  CheckNotConvertibleTo<Array&, Function>();
+  CheckNotConvertibleTo<Array&, Function&>();
+  CheckNotConvertibleTo<Array&, Function*>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction&>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction*>();
+  CheckNotConvertibleTo<Array&, Array>();
+
+  static_assert(std::convertible_to<Array&, Array&>);
+  static_assert(std::convertible_to<Array&, const Array&>);
+  static_assert(!std::convertible_to<const Array&, Array&>);
+  static_assert(std::convertible_to<const Array&, const Array&>);
+
+  CheckNotConvertibleTo<Array&, char>();
+  CheckNotConvertibleTo<Array&, char&>();
+
+  static_assert(std::convertible_to<Array&, char*>);
+  static_assert(std::convertible_to<Array&, const char*>);
+  static_assert(!std::convertible_to<const Array&, char*>);
+  static_assert(std::convertible_to<const Array&, const char*>);
+
+  static_assert(std::convertible_to<Array, StringType>);
+  static_assert(std::convertible_to<char(&)[], StringType>);
+
+  // char
+  CheckNotConvertibleTo<char, void>();
+  CheckNotConvertibleTo<char, Function>();
+  CheckNotConvertibleTo<char, Function&>();
+  CheckNotConvertibleTo<char, Function*>();
+  CheckNotConvertibleTo<char, NoexceptFunction>();
+  CheckNotConvertibleTo<char, NoexceptFunction&>();
+  CheckNotConvertibleTo<char, NoexceptFunction*>();
+  CheckNotConvertibleTo<char, Array>();
+  CheckNotConvertibleTo<char, Array&>();
+
+  CheckConvertibleTo<char, char>();
+
+  static_assert(!std::convertible_to<char, char&>);
+  static_assert(std::convertible_to<char, const char&>);
+  static_assert(!std::convertible_to<const char, char&>);
+  static_assert(std::convertible_to<const char, const char&>);
+
+  CheckNotConvertibleTo<char, char*>();
+
+  // char&
+  CheckNotConvertibleTo<char&, void>();
+  CheckNotConvertibleTo<char&, Function>();
+  CheckNotConvertibleTo<char&, Function&>();
+  CheckNotConvertibleTo<char&, Function*>();
+  CheckNotConvertibleTo<char&, NoexceptFunction>();
+  CheckNotConvertibleTo<char&, NoexceptFunction&>();
+  CheckNotConvertibleTo<char&, NoexceptFunction*>();
+  CheckNotConvertibleTo<char&, Array>();
+  CheckNotConvertibleTo<char&, Array&>();
+
+  CheckConvertibleTo<char&, char>();
+
+  static_assert(std::convertible_to<char&, char&>);
+  static_assert(std::convertible_to<char&, const char&>);
+  static_assert(!std::convertible_to<const char&, char&>);
+  static_assert(std::convertible_to<const char&, const char&>);
+
+  CheckNotConvertibleTo<char&, char*>();
+
+  // char*
+  CheckNotConvertibleTo<char*, void>();
+  CheckNotConvertibleTo<char*, Function>();
+  CheckNotConvertibleTo<char*, Function&>();
+  CheckNotConvertibleTo<char*, Function*>();
+  CheckNotConvertibleTo<char*, NoexceptFunction>();
+  CheckNotConvertibleTo<char*, NoexceptFunction&>();
+  CheckNotConvertibleTo<char*, NoexceptFunction*>();
+  CheckNotConvertibleTo<char*, Array>();
+  CheckNotConvertibleTo<char*, Array&>();
+
+  CheckNotConvertibleTo<char*, char>();
+  CheckNotConvertibleTo<char*, char&>();
+
+  static_assert(std::convertible_to<char*, char*>);
+  static_assert(std::convertible_to<char*, const char*>);
+  static_assert(!std::convertible_to<const char*, char*>);
+  static_assert(std::convertible_to<const char*, const char*>);
+
+  // NonCopyable
+  static_assert(std::convertible_to<NonCopyable&, NonCopyable&>);
+  static_assert(std::convertible_to<NonCopyable&, const NonCopyable&>);
+  static_assert(std::convertible_to<NonCopyable&, const volatile NonCopyable&>);
+  static_assert(std::convertible_to<NonCopyable&, volatile NonCopyable&>);
+  static_assert(std::convertible_to<const NonCopyable&, const NonCopyable&>);
+  static_assert(
+      std::convertible_to<const NonCopyable&, const volatile NonCopyable&>);
+  static_assert(
+      std::convertible_to<volatile NonCopyable&, const volatile NonCopyable&>);
+  static_assert(std::convertible_to<const volatile NonCopyable&,
+                                    const volatile NonCopyable&>);
+  static_assert(!std::convertible_to<const NonCopyable&, NonCopyable&>);
+
+  // This test requires Access control SFINAE which we only have in C++11 or when
+  // we are using the compiler builtin for convertible_to.
+  CheckNotConvertibleTo<NonCopyable&, NonCopyable>();
+
+  // Ensure that CannotInstantiate is not instantiated by convertible_to when it is not needed.
+  // For example CannotInstantiate is instantiated as a part of ADL lookup for arguments of type CannotInstantiate*.
+  static_assert(
+      std::convertible_to<CannotInstantiate<int>*, CannotInstantiate<int>*>);
+
+  // Test for PR13592
+  static_assert(!std::convertible_to<abstract, abstract>);
+
+  CommonlyNotConvertibleTo<int>();
+  CommonlyNotConvertibleTo<bool>();
+  CommonlyNotConvertibleTo<nullptr_t>();
+
+  CheckNotConvertibleTo<int, ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ExplicitlyConvertible, ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ExplicitlyConstructible, ExplicitlyConvertible>();
+  CheckIsConvertibleButNotConvertibleTo<ImplicitlyConvertible,
+                                        ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ImplicitlyConstructible, ImplicitlyConvertible>();
+
+  return 0;
+}