Index: libcxx/include/concepts
===================================================================
--- libcxx/include/concepts
+++ libcxx/include/concepts
@@ -163,6 +163,17 @@
 concept derived_from =
   __is_base_of(_Bp, _Dp) && __is_convertible_to(const volatile _Dp*, const volatile _Bp*);
 
+// [concept.convertible]
+
+template<class _Fp, class _Tp>
+inline constexpr auto __is_explicitly_convertible =
+  requires(add_rvalue_reference_t<_Fp> (&__f)()) {
+    static_cast<_Tp>(__f());
+  };
+
+template<class _Fp, class _Tp>
+concept convertible_to = __is_convertible_to(_Fp, _Tp) && __is_explicitly_convertible<_Fp, _Tp>;
+
 #endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
Index: libcxx/test/std/concepts/lang/convertible_to.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/concepts/lang/convertible_to.pass.cpp
@@ -0,0 +1,507 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+template <class From, class To, template <class> class Mod1,
+          template <class> class Mod2>
+constexpr void NotConvertible() {
+  static_assert(
+      !std::convertible_to<typename Mod1<From>::type, typename Mod2<To>::type>);
+  static_assert(
+      !std::convertible_to<typename Mod2<To>::type, typename Mod1<From>::type>);
+}
+
+template <class From, class To, template <class> class Mod1,
+          template <class> class Mod2>
+constexpr void OneWayConvertible() {
+  static_assert(
+      std::convertible_to<typename Mod1<From>::type, typename Mod2<To>::type>);
+  static_assert(
+      !std::convertible_to<typename Mod2<To>::type, typename Mod1<From>::type>);
+}
+
+template <class From, class To, template <class> class Mod1,
+          template <class> class Mod2>
+constexpr void TwoWayConvertible() {
+  static_assert(
+      std::convertible_to<typename Mod1<From>::type, typename Mod2<To>::type>);
+  static_assert(
+      std::convertible_to<typename Mod2<To>::type, typename Mod1<From>::type>);
+}
+
+struct S {};
+enum Enumeration { No, Yes };
+enum class ScopedEnumeration { Yes, No };
+template <typename T>
+struct Identity {
+  using type = T;
+};
+
+// Tests that should objectively return false
+template <class T, template <class> class Mod1, template <class> class Mod2,
+          class TT = std::remove_cvref_t<T> >
+requires (!std::is_array_v<TT> && !std::is_void_v<TT> && //
+          !std::is_pointer_v<TT> && !std::is_function_v<TT> && //
+          !std::is_member_pointer_v<TT>) //
+constexpr void CommonlyNotConvertible() {
+  NotConvertible<T, void, Mod1, Mod2>();
+  NotConvertible<T, typename Mod2<T>::type*, Mod1, Identity>();
+  NotConvertible<T, typename Mod2<T>::type S::*, Mod1, Identity>();
+  NotConvertible<T, typename Mod2<T>::type (S::*)(), Mod1, Identity>();
+  NotConvertible<T, typename Mod2<T>::type[sizeof(T)], Mod1, Identity>();
+  NotConvertible<T, typename Mod2<T>::type (*)(), Mod1, Identity>();
+  NotConvertible<T, typename Mod2<T>::type (&)(), Mod1, Identity>();
+}
+
+template <template <class> class Modifier>
+constexpr auto IsIdentity = std::same_as<typename Modifier<int>::type, int>;
+
+template <template <class> class Modifier>
+constexpr auto IsConst = std::is_const_v<typename Modifier<int>::type>;
+
+template <template <class> class Modifier>
+constexpr auto IsVolatile = std::is_volatile_v<typename Modifier<int>::type>;
+
+namespace Fundamentals {
+template <template <class> class Mod1, template <class> class Mod2>
+constexpr void CheckFundamentals() {
+  TwoWayConvertible<char, signed char, Mod1, Mod2>();
+  TwoWayConvertible<int, char, Mod1, Mod2>();
+  TwoWayConvertible<float, int, Mod1, Mod2>();
+  TwoWayConvertible<float, double, Mod1, Mod2>();
+
+  OneWayConvertible<Enumeration, int, Mod1, Mod2>();
+  NotConvertible<ScopedEnumeration, int, Mod1, Mod2>();
+
+  CommonlyNotConvertible<char, Mod1, Mod2>();
+  CommonlyNotConvertible<signed char, Mod1, Mod2>();
+  CommonlyNotConvertible<unsigned char, Mod1, Mod2>();
+  CommonlyNotConvertible<signed short, Mod1, Mod2>();
+  CommonlyNotConvertible<unsigned short, Mod1, Mod2>();
+  CommonlyNotConvertible<signed int, Mod1, Mod2>();
+  CommonlyNotConvertible<unsigned int, Mod1, Mod2>();
+  CommonlyNotConvertible<signed long, Mod1, Mod2>();
+  CommonlyNotConvertible<unsigned long, Mod1, Mod2>();
+  CommonlyNotConvertible<signed long long, Mod1, Mod2>();
+  CommonlyNotConvertible<unsigned long long, Mod1, Mod2>();
+  CommonlyNotConvertible<float, Mod1, Mod2>();
+  CommonlyNotConvertible<double, Mod1, Mod2>();
+  CommonlyNotConvertible<long double, Mod1, Mod2>();
+  CommonlyNotConvertible<wchar_t, Mod1, Mod2>();
+  CommonlyNotConvertible<char8_t, Mod1, Mod2>();
+  CommonlyNotConvertible<char16_t, Mod1, Mod2>();
+  CommonlyNotConvertible<char32_t, Mod1, Mod2>();
+  CommonlyNotConvertible<Enumeration, Mod1, Mod2>();
+  CommonlyNotConvertible<ScopedEnumeration, Mod1, Mod2>();
+  { // Can't check void using CommonlyNotConvertible as it's convertible to void.
+    TwoWayConvertible<void, void, Mod1, Mod2>();
+    NotConvertible<typename Mod1<int>::type*, void, Identity, Mod2>();
+    NotConvertible<typename Mod1<int>::type S::*, void, Identity, Mod2>();
+    NotConvertible<typename Mod1<int>::type (S::*)(), void, Identity, Mod2>();
+    NotConvertible<typename Mod1<int>::type[sizeof(int)], void, Identity,
+                   Mod2>();
+    NotConvertible<typename Mod1<int>::type (*)(), void, Identity, Mod2>();
+    NotConvertible<typename Mod1<int>::type (&)(), void, Identity, Mod2>();
+  }
+  { // Can't check bool using CommonlyNotConvertible as it's convertible to pointers.
+    NotConvertible<bool, void, Mod1, Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type*, bool, Identity, Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type S::*, bool, Identity, Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type (S::*)(), bool, Identity,
+                      Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type[1], bool, Identity, Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type (*)(), bool, Identity, Mod2>();
+    OneWayConvertible<typename Mod1<bool>::type (&)(), bool, Identity, Mod2>();
+  }
+  { // Can't check std::nullptr_t using CommonlyNotConvertible as it's convertible to pointers.
+    NotConvertible<decltype(nullptr), void, Mod1, Mod2>();
+    OneWayConvertible<decltype(nullptr), typename Mod2<void>::type*, Mod1,
+                      Identity>();
+    OneWayConvertible<decltype(nullptr), typename Mod2<S>::type S::*, Mod1,
+                      Identity>();
+    OneWayConvertible<decltype(nullptr), typename Mod2<void>::type (S::*)(),
+                      Mod1, Identity>();
+    NotConvertible<decltype(nullptr), typename Mod2<int>::type[1], Mod1,
+                   Identity>();
+    OneWayConvertible<decltype(nullptr), typename Mod2<void>::type (*)(), Mod1,
+                      Identity>();
+    NotConvertible<decltype(nullptr), typename Mod2<void>::type (&)(), Mod1,
+                   Identity>();
+  }
+
+  OneWayConvertible<int&, int, Identity, Mod2>();
+  TwoWayConvertible<const int&, int, Identity, Identity>();
+  TwoWayConvertible<const int&, const int, Identity, Identity>();
+  OneWayConvertible<const int&, volatile int, Identity, Identity>();
+  OneWayConvertible<const int&, const volatile int, Identity, Identity>();
+  OneWayConvertible<volatile int&, int, Identity, Mod2>();
+  OneWayConvertible<const volatile int&, int, Identity, Mod2>();
+
+  TwoWayConvertible<typename Mod1<int>::type&&, int, Identity, Identity>();
+  OneWayConvertible<int&&, const int, Identity, Identity>();
+  OneWayConvertible<int&&, volatile int, Identity, Identity>();
+  OneWayConvertible<int&&, const volatile int, Identity, Identity>();
+  TwoWayConvertible<const int&&, const int, Identity, Identity>();
+  OneWayConvertible<const int&&, volatile int, Identity, Identity>();
+  OneWayConvertible<const int&&, const volatile int, Identity, Identity>();
+  OneWayConvertible<volatile int&&, const int, Identity, Identity>();
+  TwoWayConvertible<volatile int&&, volatile int, Identity, Identity>();
+  OneWayConvertible<volatile int&&, const volatile int, Identity, Identity>();
+  TwoWayConvertible<const volatile int&&, int, Identity, Mod2>();
+}
+
+template <template <class> class Modifier>
+constexpr void CheckFundamentals() {
+  CheckFundamentals<Modifier, Identity>();
+  CheckFundamentals<Modifier, std::add_const>();
+  CheckFundamentals<Modifier, std::add_volatile>();
+  CheckFundamentals<Modifier, std::add_cv>();
+}
+
+constexpr void Check() {
+  CheckFundamentals<Identity>();
+  CheckFundamentals<std::add_const>();
+  CheckFundamentals<std::add_volatile>();
+  CheckFundamentals<std::add_cv>();
+}
+} // namespace Fundamentals
+
+namespace Aggregates {
+template <class T>
+struct Aggregate {
+  T Value;
+};
+
+struct ImplicitlyConstructible {
+  ImplicitlyConstructible(int);
+
+  int Value;
+};
+
+struct ImplicitlyConvertible {
+  operator int();
+
+  int Value;
+};
+
+struct ImplicitlyConvertibleConst {
+  operator int() const;
+
+  int value;
+};
+
+struct ImplicitlyConvertibleVolatile {
+  operator int() volatile;
+
+  int value;
+};
+
+struct ImplicitlyConvertibleCV {
+  operator int() const volatile;
+
+  int Value;
+};
+
+struct ImplicitlyConstructibleAndConvertible {
+  ImplicitlyConstructibleAndConvertible(float);
+  operator float();
+
+  float Value;
+};
+
+struct ImplicitlyConstructibleAndConvertibleConst {
+  ImplicitlyConstructibleAndConvertibleConst(char);
+  operator char() const;
+
+  char Value;
+};
+
+struct ImplicitlyConstructibleAndConvertibleVolatile {
+  ImplicitlyConstructibleAndConvertibleVolatile(long long);
+  operator long long() volatile;
+
+  long long Value;
+};
+
+struct ImplicitlyConstructibleAndConvertibleCV {
+  ImplicitlyConstructibleAndConvertibleCV(int);
+  operator int() const volatile;
+
+  int Value;
+};
+
+struct ExplicitlyConstructible {
+  using T = double (S::*)(double, double);
+
+  explicit ExplicitlyConstructible(T);
+
+  T Value;
+};
+
+struct ExplicitlyConvertible {
+  using T = S S::*;
+
+  explicit operator T();
+
+  T value;
+};
+struct ExplicitlyConvertibleConst {
+  using T = void (*)();
+
+  explicit operator T() const;
+
+  T value;
+};
+struct ExplicitlyConvertibleVolatile {
+  explicit operator signed char() volatile;
+
+  signed char value;
+};
+struct ExplicitlyConvertibleCV {
+  explicit operator long long() const volatile;
+
+  long long Value;
+};
+
+struct ExplicitlyConstructibleAndImplicitlyConvertible {
+  explicit ExplicitlyConstructibleAndImplicitlyConvertible(int);
+  operator int();
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndImplicitlyConvertibleConst {
+  explicit ExplicitlyConstructibleAndImplicitlyConvertibleConst(int);
+  operator int() const;
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndImplicitlyConvertibleVolatile {
+  explicit ExplicitlyConstructibleAndImplicitlyConvertibleVolatile(int);
+  operator int() volatile;
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndImplicitlyConvertibleCV {
+  explicit ExplicitlyConstructibleAndImplicitlyConvertibleCV(int);
+  operator int() const volatile;
+
+  int Value;
+};
+
+struct ExplicitlyConstructibleAndConvertible {
+  explicit ExplicitlyConstructibleAndConvertible(int);
+  explicit operator int();
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndConvertibleConst {
+  explicit ExplicitlyConstructibleAndConvertibleConst(int);
+  explicit operator int() const;
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndConvertibleVolatile {
+  explicit ExplicitlyConstructibleAndConvertibleVolatile(int);
+  explicit operator int() volatile;
+
+  int Value;
+};
+struct ExplicitlyConstructibleAndConvertibleCV {
+  explicit ExplicitlyConstructibleAndConvertibleCV(int);
+  explicit operator int() const volatile;
+
+  int Value;
+};
+
+struct ImplicitlyConstructibleAndExplicitlyConvertible {
+  ImplicitlyConstructibleAndExplicitlyConvertible(long*);
+
+  explicit operator long*();
+};
+struct ImplicitlyConstructibleAndExplicitlyConvertibleConst {
+  ImplicitlyConstructibleAndExplicitlyConvertibleConst(const long*);
+
+  explicit operator const long*() const;
+};
+struct ImplicitlyConstructibleAndExplicitlyConvertibleVolatile {
+  ImplicitlyConstructibleAndExplicitlyConvertibleVolatile(volatile long*);
+
+  explicit operator volatile long*() volatile;
+};
+struct ImplicitlyConstructibleAndExplicitlyConvertibleCV {
+  ImplicitlyConstructibleAndExplicitlyConvertibleCV(const volatile long*);
+
+  explicit operator const volatile long *() volatile;
+};
+
+template <class T, bool MeetsRequirements, template <class> class Mod1,
+          template <class> class Mod2>
+constexpr void CheckImplicitlyConvertible() {
+  if constexpr (MeetsRequirements) {
+    OneWayConvertible<T, int, Mod1, Mod2>();
+    OneWayConvertible<T, double, Mod1, Mod2>();
+  } else {
+    NotConvertible<T, int, Mod1, Mod2>();
+    NotConvertible<T, double, Mod1, Mod2>();
+  }
+
+  CommonlyNotConvertible<T, Mod1, Mod2>();
+}
+
+template <class T, bool MeetsRequirements, template <class> class Mod1,
+          template <class> class Mod2>
+constexpr void CheckImplicitlyConstructibleAndConvertible() {
+  if constexpr (MeetsRequirements) {
+    TwoWayConvertible<T, int, Mod1, Mod2>();
+    TwoWayConvertible<T, double, Mod1, Mod2>();
+  } else {
+    OneWayConvertible<int, T, Mod2, Mod1>();
+    OneWayConvertible<double, T, Mod2, Mod1>();
+  }
+
+  CommonlyNotConvertible<T, Mod1, Mod2>();
+}
+
+template <template <class> class Mod1, template <class> class Mod2>
+constexpr void CheckAggregates() {
+  {
+    NotConvertible<Aggregate<double>, double, Mod1, Mod2>();
+    CommonlyNotConvertible<Aggregate<double>, Mod1, Mod2>();
+
+    NotConvertible<Aggregate<Aggregate<double> >, Aggregate<double>, Mod1,
+                   Mod2>();
+    NotConvertible<double, Aggregate<Aggregate<double> >, Mod1, Mod2>();
+    CommonlyNotConvertible<Aggregate<Aggregate<double> >, Mod1, Mod2>();
+  }
+  {
+    OneWayConvertible<int, ImplicitlyConstructible, Mod1, Mod2>();
+    OneWayConvertible<double, ImplicitlyConstructible, Mod1, Mod2>();
+    CommonlyNotConvertible<ImplicitlyConstructible, Mod1, Mod2>();
+  }
+  {
+    CheckImplicitlyConvertible<ImplicitlyConvertible, IsIdentity<Mod1>, Mod1,
+                               Mod2>();
+    CheckImplicitlyConvertible<ImplicitlyConvertibleConst, !IsVolatile<Mod1>,
+                               Mod1, Mod2>();
+    CheckImplicitlyConvertible<ImplicitlyConvertibleVolatile, !IsConst<Mod1>,
+                               Mod1, Mod2>();
+    CheckImplicitlyConvertible<ImplicitlyConvertibleCV, true, Mod1, Mod2>();
+  }
+  {
+    CheckImplicitlyConstructibleAndConvertible<
+        ImplicitlyConstructibleAndConvertible, IsIdentity<Mod1>, Mod1, Mod2>();
+    CheckImplicitlyConstructibleAndConvertible<
+        ImplicitlyConstructibleAndConvertibleConst, !IsVolatile<Mod1>, Mod1,
+        Mod2>();
+    CheckImplicitlyConstructibleAndConvertible<
+        ImplicitlyConstructibleAndConvertibleVolatile, !IsConst<Mod1>, Mod1,
+        Mod2>();
+    CheckImplicitlyConstructibleAndConvertible<
+        ImplicitlyConstructibleAndConvertibleCV, true, Mod1, Mod2>();
+  }
+  {
+    NotConvertible<ExplicitlyConstructible::T, ExplicitlyConstructible, Mod1,
+                   Mod2>();
+    CommonlyNotConvertible<ExplicitlyConstructible, Mod1, Mod2>();
+  }
+  {
+    NotConvertible<ExplicitlyConvertible, long long, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConvertible, Mod1, Mod2>();
+
+    NotConvertible<ExplicitlyConvertibleConst, long long, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConvertibleConst, Mod1, Mod2>();
+
+    NotConvertible<ExplicitlyConvertibleVolatile, long long, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConvertibleVolatile, Mod1, Mod2>();
+
+    NotConvertible<ExplicitlyConvertibleCV, long long, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConvertibleCV, Mod1, Mod2>();
+  }
+  {
+    CheckImplicitlyConvertible<ExplicitlyConstructibleAndImplicitlyConvertible,
+                               IsIdentity<Mod1>, Mod1, Mod2>();
+    CheckImplicitlyConvertible<
+        ExplicitlyConstructibleAndImplicitlyConvertibleConst, !IsVolatile<Mod1>,
+        Mod1, Mod2>();
+    CheckImplicitlyConvertible<
+        ExplicitlyConstructibleAndImplicitlyConvertibleVolatile, !IsConst<Mod1>,
+        Mod1, Mod2>();
+    CheckImplicitlyConvertible<
+        ExplicitlyConstructibleAndImplicitlyConvertibleCV, true, Mod1, Mod2>();
+  }
+  {
+    NotConvertible<ExplicitlyConstructibleAndConvertible, int, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConstructibleAndConvertible, Mod1, Mod2>();
+    NotConvertible<ExplicitlyConstructibleAndConvertibleConst, int, Mod1,
+                   Mod2>();
+    CommonlyNotConvertible<ExplicitlyConstructibleAndConvertibleConst, Mod1,
+                           Mod2>();
+    NotConvertible<ExplicitlyConstructibleAndConvertibleVolatile, int, Mod1,
+                   Mod2>();
+    CommonlyNotConvertible<ExplicitlyConstructibleAndConvertibleVolatile, Mod1,
+                           Mod2>();
+    NotConvertible<ExplicitlyConstructibleAndConvertibleCV, int, Mod1, Mod2>();
+    CommonlyNotConvertible<ExplicitlyConstructibleAndConvertibleCV, Mod1,
+                           Mod2>();
+  }
+  {
+    OneWayConvertible<long*, ImplicitlyConstructibleAndExplicitlyConvertible,
+                      Mod1, Mod2>();
+    OneWayConvertible<long*,
+                      ImplicitlyConstructibleAndExplicitlyConvertibleConst,
+                      Mod1, Mod2>();
+    OneWayConvertible<long*,
+                      ImplicitlyConstructibleAndExplicitlyConvertibleVolatile,
+                      Mod1, Mod2>();
+    OneWayConvertible<long*, ImplicitlyConstructibleAndExplicitlyConvertibleCV,
+                      Mod1, Mod2>();
+  }
+}
+
+template <template <class> class Modifier>
+constexpr void CheckAggregates() {
+  CheckAggregates<Modifier, Identity>();
+  CheckAggregates<Modifier, std::add_const>();
+  CheckAggregates<Modifier, std::add_volatile>();
+  CheckAggregates<Modifier, std::add_cv>();
+}
+
+constexpr void Check() {
+  CheckAggregates<Identity>();
+  CheckAggregates<std::add_const>();
+  CheckAggregates<std::add_volatile>();
+  CheckAggregates<std::add_cv>();
+}
+} // namespace Aggregates
+
+namespace Derived {
+// TODO(cjdb@)
+} // namespace Derived
+
+namespace Polyconstructible {
+// TODO(cjdb@)
+} // namespace Polyconstructible
+
+namespace Polyconvertible {
+// TODO(cjdb@)
+} // namespace Polyconvertible
+
+int main(int, char**) {
+  Fundamentals::Check();
+  Aggregates::Check();
+
+  return 0;
+}