[libcxx] adds concept std::derived_from

[cjdb]

Summary

Implements parts of:

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

[miscco]

libcxx/include/concepts

177–180

As before, this needs _Uglification.

Also note that is_base_of_v directly goes back to __is_base_of and you have the chain

__is_base_of -> i_base_of -> is_base_of_v

(See https://github.com/miscco/llvm-project/blob/bc29069dc401572ba62f7dd692a3474c1ead76c9/libcxx/include/type_traits#L1417-L1425)

So throughput would be better it you would again specialize for __clang__ and use __Is_base_of directly

[CaseyCarter]

libcxx/include/concepts

177–180

__is_base_of(Base, Derived) is available in all versions of clang/GCC/MSVC that support concepts (https://godbolt.org/z/xfLGbF).

__is_convertible_to(From, To) is available in clang/MSVC versions that support concepts (https://godbolt.org/z/jQEEr5). clang also supports the name __is_convertible.

[cjdb]

Updates tests to check for fundamental(ish) types, cv-qualifiers, references, pointers, void, functions, pointer-to-functions, reference-to-functions, pointer-to-member(-functions), and arrays.

[cjdb]

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

44

I'm not sure if the rvalue-reference checks are necessary, or if static_assert(!std::derived_from<From*, To>) covers this.
CC @CaseyCarter

[cjdb]

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

44

Yes, they are, and that's the point of this check.

[miscco]

One correctness comment and some minor nits

libcxx/include/concepts

177–180

If I understand @CaseyCarter correctly then __is_convertible_to is not available with gcc so I guess we should use is_convertible_v

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

23

I would suggest a better name maybe Derived_private and Derived_public instead of Derived1/Base2 same for protected

153

That newline is not consistent with the other sections. That said i personally prefer a newline here.

[cjdb]

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

23

Done.

153

Newline is because of the comment.

[cjdb]

This patch should be ready to check in, per @ldionne's approval.

[ldionne]

I added the LLVM Monorepo to the revision - this will allow CI to trigger if you update the patch. Can you please rebase and re-upload? This LGTM if CI passes, but I think you might need to use is_convertible_v to fix the build on GCC. CI will tell.

[cjdb]

In D74292#2528404, @ldionne wrote:

I added the LLVM Monorepo to the revision - this will allow CI to trigger if you update the patch. Can you please rebase and re-upload? This LGTM if CI passes, but I think you might need to use is_convertible_v to fix the build on GCC. CI will tell.

Done, but I don't see any CI panel showing up. Did I do something wrong?

[cjdb]

Trying to activate CI

[cjdb]

Activates CI

[cjdb]

Selects __is_convertible_to or std::is_convertible_v based on compiler.

[cjdb]

Helps if the right patch is uploaded.

[cjdb]

CI seemed to fail, retrying

[cjdb]

updates commit message

[ldionne]

libcxx/include/concepts

168

I thought I had left a comment here, but I would prefer that we de-duplicate this implementation and unconditionally use is_convertible_v (as mentioned on other patches).

[cjdb]

applies @zoecarver's fix and @ldionne's fix

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.derived]
+
+template<class _Dp, class _Bp>
+concept derived_from =
+  __is_base_of(_Bp, _Dp) && __is_convertible_to(const volatile _Dp*, const volatile _Bp*);
+
 // [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/derived_from.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 Derived, class Base>
+// concept derived_from;
+
+#include <concepts>
+#include <type_traits>
+
+struct Base1 {};
+struct Derived1 : Base1 {};
+struct Derived2 : Base1 {};
+
+struct DerivedPrivate : private Base1 {};
+struct Derived3 : DerivedPrivate {};
+
+struct DerivedProtected : protected DerivedPrivate {};
+struct Derived4 : DerivedProtected {};
+struct Derived5 : Derived4 {};
+
+template <typename From, typename To>
+constexpr void CheckNotDerivedFromPointer() {
+  { // From as pointer
+    static_assert(!std::derived_from<From*, To>);
+    static_assert(!std::derived_from<From*, const To>);
+    static_assert(!std::derived_from<From*, volatile To>);
+    static_assert(!std::derived_from<From*, const volatile To>);
+
+    if constexpr (!std::same_as<To, void>) {
+      static_assert(!std::derived_from<From*, To&>);
+      static_assert(!std::derived_from<From*, const To&>);
+      static_assert(!std::derived_from<From*, volatile To&>);
+      static_assert(!std::derived_from<From*, const volatile To&>);
+
+      static_assert(!std::derived_from<From*, To&&>);
+      static_assert(!std::derived_from<From*, const To&&>);
+      static_assert(!std::derived_from<From*, volatile To&&>);
+      static_assert(!std::derived_from<From*, const volatile To&&>);
+
+      static_assert(!std::derived_from<const From*, To&>);
+      static_assert(!std::derived_from<const From*, const To&>);
+      static_assert(!std::derived_from<const From*, volatile To&>);
+      static_assert(!std::derived_from<const From*, const volatile To&>);
+
+      static_assert(!std::derived_from<const From*, To&&>);
+      static_assert(!std::derived_from<const From*, const To&&>);
+      static_assert(!std::derived_from<const From*, volatile To&&>);
+      static_assert(!std::derived_from<const From*, const volatile To&&>);
+
+      static_assert(!std::derived_from<volatile From*, To&>);
+      static_assert(!std::derived_from<volatile From*, const To&>);
+      static_assert(!std::derived_from<volatile From*, volatile To&>);
+      static_assert(!std::derived_from<volatile From*, const volatile To&>);
+
+      static_assert(!std::derived_from<volatile From*, To&&>);
+      static_assert(!std::derived_from<volatile From*, const To&&>);
+      static_assert(!std::derived_from<volatile From*, volatile To&&>);
+      static_assert(!std::derived_from<volatile From*, const volatile To&&>);
+
+      static_assert(!std::derived_from<const volatile From*, To&>);
+      static_assert(!std::derived_from<const volatile From*, const To&>);
+      static_assert(!std::derived_from<const volatile From*, volatile To&>);
+      static_assert(
+          !std::derived_from<const volatile From*, const volatile To&>);
+
+      static_assert(!std::derived_from<const volatile From*, To&&>);
+      static_assert(!std::derived_from<const volatile From*, const To&&>);
+      static_assert(!std::derived_from<const volatile From*, volatile To&&>);
+      static_assert(
+          !std::derived_from<const volatile From*, const volatile To&&>);
+    }
+  }
+  { // To as pointer
+    static_assert(!std::derived_from<From, To*>);
+    static_assert(!std::derived_from<From, const To*>);
+    static_assert(!std::derived_from<From, volatile To*>);
+    static_assert(!std::derived_from<From, const volatile To*>);
+
+    if constexpr (!std::same_as<From, void>) {
+      static_assert(!std::derived_from<From&, To*>);
+      static_assert(!std::derived_from<From&, const To*>);
+      static_assert(!std::derived_from<From&, volatile To*>);
+      static_assert(!std::derived_from<From&, const volatile To*>);
+
+      static_assert(!std::derived_from<From&&, To*>);
+      static_assert(!std::derived_from<From&&, const To*>);
+      static_assert(!std::derived_from<From&&, volatile To*>);
+      static_assert(!std::derived_from<From&&, const volatile To*>);
+
+      static_assert(!std::derived_from<const From&, To*>);
+      static_assert(!std::derived_from<const From&, const To*>);
+      static_assert(!std::derived_from<const From&, volatile To*>);
+      static_assert(!std::derived_from<const From&, const volatile To*>);
+
+      static_assert(!std::derived_from<const From&&, To*>);
+      static_assert(!std::derived_from<const From&&, const To*>);
+      static_assert(!std::derived_from<const From&&, volatile To*>);
+      static_assert(!std::derived_from<const From&&, const volatile To*>);
+
+      static_assert(!std::derived_from<volatile From&, To*>);
+      static_assert(!std::derived_from<volatile From&, const To*>);
+      static_assert(!std::derived_from<volatile From&, volatile To*>);
+      static_assert(!std::derived_from<volatile From&, const volatile To*>);
+
+      static_assert(!std::derived_from<volatile From&&, To*>);
+      static_assert(!std::derived_from<volatile From&&, const To*>);
+      static_assert(!std::derived_from<volatile From&&, volatile To*>);
+      static_assert(!std::derived_from<volatile From&&, const volatile To*>);
+
+      static_assert(!std::derived_from<const volatile From&, To*>);
+      static_assert(!std::derived_from<const volatile From&, const To*>);
+      static_assert(!std::derived_from<const volatile From&, volatile To*>);
+      static_assert(
+          !std::derived_from<const volatile From&, const volatile To*>);
+
+      static_assert(!std::derived_from<const volatile From&&, To*>);
+      static_assert(!std::derived_from<const volatile From&&, const To*>);
+      static_assert(!std::derived_from<const volatile From&&, volatile To*>);
+      static_assert(
+          !std::derived_from<const volatile From&&, const volatile To*>);
+    }
+  }
+  { // Both as pointers
+    static_assert(!std::derived_from<From*, To*>);
+    static_assert(!std::derived_from<From*, const To*>);
+    static_assert(!std::derived_from<From*, volatile To*>);
+    static_assert(!std::derived_from<From*, const volatile To*>);
+
+    static_assert(!std::derived_from<const From*, To*>);
+    static_assert(!std::derived_from<const From*, const To*>);
+    static_assert(!std::derived_from<const From*, volatile To*>);
+    static_assert(!std::derived_from<const From*, const volatile To*>);
+
+    static_assert(!std::derived_from<volatile From*, To*>);
+    static_assert(!std::derived_from<volatile From*, const To*>);
+    static_assert(!std::derived_from<volatile From*, volatile To*>);
+    static_assert(!std::derived_from<volatile From*, const volatile To*>);
+
+    static_assert(!std::derived_from<const volatile From*, To*>);
+    static_assert(!std::derived_from<const volatile From*, const To*>);
+    static_assert(!std::derived_from<const volatile From*, volatile To*>);
+    static_assert(!std::derived_from<const volatile From*, const volatile To*>);
+  }
+
+  // From as the return type of a pointer-to-function
+  if constexpr (!std::is_array_v<From>) {
+    static_assert(!std::derived_from<From (*)(), To>);
+    static_assert(!std::derived_from<From (*)(int), To>);
+  }
+
+  // To as the return type of a pointer-to-function
+  if constexpr (!std::is_array_v<To>) {
+    static_assert(!std::derived_from<From, To (*)()>);
+    static_assert(!std::derived_from<From, To (*)(double)>);
+  }
+
+  // Both as the return type of a pointer-to-function
+  if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
+    static_assert(!std::derived_from<From (*)(), To (*)()>);
+    static_assert(!std::derived_from<From (*)(int), To (*)(double)>);
+  }
+  { // pointer-to-member
+    if constexpr (std::is_class_v<From> && !std::same_as<To, void>) {
+      static_assert(!std::derived_from<To From::*, To>);
+    }
+
+    if constexpr (std::is_class_v<To> && !std::same_as<From, void>) {
+      static_assert(!std::derived_from<From To::*, From>);
+    }
+  }
+  { // pointer-to-member-functions
+    if constexpr (std::is_class_v<From>) {
+      static_assert(!std::derived_from<From (From::*)(), To>);
+    }
+
+    if constexpr (std::is_class_v<To>) {
+      static_assert(!std::derived_from<To (To::*)(), From>);
+    }
+  }
+}
+
+template <typename From, typename To>
+constexpr void CheckNotDerivedFromReference() {
+  if constexpr (!std::same_as<To, void>) {
+    static_assert(!std::derived_from<From, To&>);
+    static_assert(!std::derived_from<From, const To&>);
+    static_assert(!std::derived_from<From, volatile To&>);
+    static_assert(!std::derived_from<From, const volatile To&>);
+
+    static_assert(!std::derived_from<From, To&&>);
+    static_assert(!std::derived_from<From, const To&&>);
+    static_assert(!std::derived_from<From, volatile To&&>);
+    static_assert(!std::derived_from<From, const volatile To&&>);
+  }
+
+  if constexpr (!std::same_as<From, void>) {
+    static_assert(!std::derived_from<From&, To>);
+    static_assert(!std::derived_from<From&, To>);
+    static_assert(!std::derived_from<From&, To>);
+    static_assert(!std::derived_from<From&, To>);
+
+    static_assert(!std::derived_from<From&&, To>);
+    static_assert(!std::derived_from<From&&, To>);
+    static_assert(!std::derived_from<From&&, To>);
+    static_assert(!std::derived_from<From&&, To>);
+  }
+
+  // From as lvalue references
+  if constexpr (!std::same_as<From, void> && !std::same_as<To, void>) {
+    static_assert(!std::derived_from<From&, To&>);
+    static_assert(!std::derived_from<From&, const To&>);
+    static_assert(!std::derived_from<From&, volatile To&>);
+    static_assert(!std::derived_from<From&, const volatile To&>);
+
+    static_assert(!std::derived_from<From&, To&&>);
+    static_assert(!std::derived_from<From&, const To&&>);
+    static_assert(!std::derived_from<From&, volatile To&&>);
+    static_assert(!std::derived_from<From&, const volatile To&&>);
+
+    static_assert(!std::derived_from<const From&, To&>);
+    static_assert(!std::derived_from<const From&, const To&>);
+    static_assert(!std::derived_from<const From&, volatile To&>);
+    static_assert(!std::derived_from<const From&, const volatile To&>);
+
+    static_assert(!std::derived_from<const From&, To&&>);
+    static_assert(!std::derived_from<const From&, const To&&>);
+    static_assert(!std::derived_from<const From&, volatile To&&>);
+    static_assert(!std::derived_from<const From&, const volatile To&&>);
+
+    static_assert(!std::derived_from<volatile From&, To&>);
+    static_assert(!std::derived_from<volatile From&, const To&>);
+    static_assert(!std::derived_from<volatile From&, volatile To&>);
+    static_assert(!std::derived_from<volatile From&, const volatile To&>);
+
+    static_assert(!std::derived_from<volatile From&, To&&>);
+    static_assert(!std::derived_from<volatile From&, const To&&>);
+    static_assert(!std::derived_from<volatile From&, volatile To&&>);
+    static_assert(!std::derived_from<volatile From&, const volatile To&&>);
+
+    static_assert(!std::derived_from<const volatile From&, To&>);
+    static_assert(!std::derived_from<const volatile From&, const To&>);
+    static_assert(!std::derived_from<const volatile From&, volatile To&>);
+    static_assert(!std::derived_from<const volatile From&, const volatile To&>);
+
+    static_assert(!std::derived_from<const volatile From&, To&&>);
+    static_assert(!std::derived_from<const volatile From&, const To&&>);
+    static_assert(!std::derived_from<const volatile From&, volatile To&&>);
+    static_assert(
+        !std::derived_from<const volatile From&, const volatile To&&>);
+
+    // From as rvalue references
+    static_assert(!std::derived_from<From&&, To&>);
+    static_assert(!std::derived_from<From&&, const To&>);
+    static_assert(!std::derived_from<From&&, volatile To&>);
+    static_assert(!std::derived_from<From&&, const volatile To&>);
+
+    static_assert(!std::derived_from<From&&, To&&>);
+    static_assert(!std::derived_from<From&&, const To&&>);
+    static_assert(!std::derived_from<From&&, volatile To&&>);
+    static_assert(!std::derived_from<From&&, const volatile To&&>);
+
+    static_assert(!std::derived_from<const From&&, To&>);
+    static_assert(!std::derived_from<const From&&, const To&>);
+    static_assert(!std::derived_from<const From&&, volatile To&>);
+    static_assert(!std::derived_from<const From&&, const volatile To&>);
+
+    static_assert(!std::derived_from<const From&&, To&&>);
+    static_assert(!std::derived_from<const From&&, const To&&>);
+    static_assert(!std::derived_from<const From&&, volatile To&&>);
+    static_assert(!std::derived_from<const From&&, const volatile To&&>);
+
+    static_assert(!std::derived_from<volatile From&&, To&>);
+    static_assert(!std::derived_from<volatile From&&, const To&>);
+    static_assert(!std::derived_from<volatile From&&, volatile To&>);
+    static_assert(!std::derived_from<volatile From&&, const volatile To&>);
+
+    static_assert(!std::derived_from<volatile From&&, To&&>);
+    static_assert(!std::derived_from<volatile From&&, const To&&>);
+    static_assert(!std::derived_from<volatile From&&, volatile To&&>);
+    static_assert(!std::derived_from<volatile From&&, const volatile To&&>);
+
+    static_assert(!std::derived_from<const volatile From&&, To&>);
+    static_assert(!std::derived_from<const volatile From&&, const To&>);
+    static_assert(!std::derived_from<const volatile From&&, volatile To&>);
+    static_assert(
+        !std::derived_from<const volatile From&&, const volatile To&>);
+
+    static_assert(!std::derived_from<const volatile From&&, To&&>);
+    static_assert(!std::derived_from<const volatile From&&, const To&&>);
+    static_assert(!std::derived_from<const volatile From&&, volatile To&&>);
+    static_assert(
+        !std::derived_from<const volatile From&&, const volatile To&&>);
+  }
+
+  // From as the return type of a reference-to-function
+  if constexpr (!std::is_array_v<From>) {
+    static_assert(!std::derived_from<From (&)(), To>);
+    static_assert(!std::derived_from<From (&)(int), To>);
+  }
+  // To as the return type of a reference-to-function
+  if constexpr (!std::is_array_v<To>) {
+    static_assert(!std::derived_from<From, To (&)()>);
+    static_assert(!std::derived_from<From, To (&)(double)>);
+  }
+  // Both as the return type of a reference-to-function
+  if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
+    static_assert(!std::derived_from<From (&)(), To (&)()>);
+    static_assert(!std::derived_from<From (&)(int), To (&)(double)>);
+  }
+}
+
+template <typename From, typename To>
+constexpr void CheckDerivedFrom() {
+  static_assert(std::derived_from<From, To>);
+
+  static_assert(std::derived_from<From, const To>);
+  static_assert(std::derived_from<From, volatile To>);
+  static_assert(std::derived_from<From, const volatile To>);
+
+  static_assert(std::derived_from<const From, const To>);
+  static_assert(std::derived_from<const From, volatile To>);
+  static_assert(std::derived_from<const From, const volatile To>);
+
+  static_assert(std::derived_from<volatile From, const To>);
+  static_assert(std::derived_from<volatile From, volatile To>);
+  static_assert(std::derived_from<volatile From, const volatile To>);
+
+  static_assert(std::derived_from<const volatile From, const To>);
+  static_assert(std::derived_from<const volatile From, volatile To>);
+  static_assert(std::derived_from<const volatile From, const volatile To>);
+
+  CheckNotDerivedFromPointer<From, To>();
+  CheckNotDerivedFromReference<From, To>();
+}
+
+template <typename From, typename To>
+constexpr void CheckNotDerivedFrom() {
+  static_assert(!std::derived_from<From, To>);
+
+  static_assert(!std::derived_from<From, const To>);
+  static_assert(!std::derived_from<From, volatile To>);
+  static_assert(!std::derived_from<From, const volatile To>);
+
+  static_assert(!std::derived_from<const From, const To>);
+  static_assert(!std::derived_from<const From, volatile To>);
+  static_assert(!std::derived_from<const From, const volatile To>);
+
+  static_assert(!std::derived_from<volatile From, const To>);
+  static_assert(!std::derived_from<volatile From, volatile To>);
+  static_assert(!std::derived_from<volatile From, const volatile To>);
+
+  static_assert(!std::derived_from<const volatile From, const To>);
+  static_assert(!std::derived_from<const volatile From, volatile To>);
+  static_assert(!std::derived_from<const volatile From, const volatile To>);
+
+  CheckNotDerivedFromPointer<From, To>();
+  CheckNotDerivedFromReference<From, To>();
+}
+
+enum Enumeration { Yes, No };
+enum class ScopedEnumeration : int { No, Yes };
+
+int main(int, char**) {
+  { // Fundamentals shouldn't be derived from anything
+    CheckNotDerivedFrom<int, long>();
+    CheckNotDerivedFrom<signed char, char>();
+    CheckNotDerivedFrom<double, Base1>();
+
+    CheckNotDerivedFrom<int, Enumeration>();
+    CheckNotDerivedFrom<int, ScopedEnumeration>();
+
+    CheckNotDerivedFrom<void, void>();
+    CheckNotDerivedFrom<int, int>();
+  }
+  { // Nothing should be derived from a fundamental type
+    CheckNotDerivedFrom<Enumeration, int>();
+    CheckNotDerivedFrom<ScopedEnumeration, int>();
+
+    CheckNotDerivedFrom<Base1, int>();
+    CheckNotDerivedFrom<Base1, double>();
+    CheckNotDerivedFrom<Derived1, char>();
+    CheckNotDerivedFrom<DerivedPrivate, long long>();
+  }
+  { // Other built-in things shouldn't have derivations
+    CheckNotDerivedFrom<Enumeration, Enumeration>();
+    CheckNotDerivedFrom<ScopedEnumeration, ScopedEnumeration>();
+
+    CheckNotDerivedFrom<Enumeration, ScopedEnumeration>();
+    CheckNotDerivedFrom<ScopedEnumeration, Enumeration>();
+
+    CheckNotDerivedFrom<Base1[5], Base1>();
+    CheckNotDerivedFrom<Derived1[5], Base1>();
+
+    CheckNotDerivedFrom<Base1, Base1[5]>();
+    CheckNotDerivedFrom<Derived1, Base1[5]>();
+  }
+
+  { // Base1 is the subject.
+    CheckDerivedFrom<Base1, Base1>();
+
+    CheckNotDerivedFrom<Base1, void>();
+    CheckNotDerivedFrom<Base1, DerivedPrivate>();
+    CheckNotDerivedFrom<Base1, DerivedProtected>();
+    CheckNotDerivedFrom<Base1, Derived1>();
+    CheckNotDerivedFrom<Base1, Derived2>();
+    CheckNotDerivedFrom<Base1, Derived3>();
+    CheckNotDerivedFrom<Base1, Derived4>();
+  }
+
+  { // Derived1 is the subject.
+    CheckDerivedFrom<Derived1, Base1>();
+    CheckDerivedFrom<Derived1, Derived1>();
+
+    CheckNotDerivedFromPointer<Derived1, void>();
+    CheckNotDerivedFrom<Derived1, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived1, DerivedProtected>();
+    CheckNotDerivedFrom<Derived1, Derived2>();
+    CheckNotDerivedFrom<Derived1, Derived3>();
+    CheckNotDerivedFrom<Derived1, Derived4>();
+  }
+
+  { // Derived2 is the subject.
+    CheckDerivedFrom<Derived2, Base1>();
+    CheckDerivedFrom<Derived2, Derived2>();
+
+    CheckNotDerivedFrom<Derived2, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived2, DerivedProtected>();
+    CheckNotDerivedFrom<Derived2, Derived1>();
+    CheckNotDerivedFrom<Derived2, Derived3>();
+    CheckNotDerivedFrom<Derived2, Derived4>();
+  }
+
+  { // DerivedPrivate is the subject.
+    CheckDerivedFrom<DerivedPrivate, DerivedPrivate>();
+
+    CheckNotDerivedFrom<DerivedPrivate, Base1>();
+    CheckNotDerivedFrom<DerivedPrivate, DerivedProtected>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived1>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived2>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived3>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived4>();
+  }
+
+  { // Derived3 is the subject.
+    CheckDerivedFrom<Derived3, DerivedPrivate>();
+    CheckDerivedFrom<Derived3, Derived3>();
+
+    CheckNotDerivedFrom<Derived3, Base1>();
+    CheckNotDerivedFrom<Derived3, DerivedProtected>();
+    CheckNotDerivedFrom<Derived3, Derived1>();
+    CheckNotDerivedFrom<Derived3, Derived2>();
+    CheckNotDerivedFrom<Derived3, Derived4>();
+  }
+
+  { // DerivedProtected is the subject.
+    CheckDerivedFrom<DerivedProtected, DerivedProtected>();
+
+    CheckNotDerivedFromPointer<DerivedProtected, Base1>();
+    CheckNotDerivedFromPointer<DerivedProtected, DerivedPrivate>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived1>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived2>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived3>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived4>();
+  }
+
+  { // Derived4 is the subject.
+    CheckDerivedFrom<Derived4, DerivedProtected>();
+    CheckDerivedFrom<Derived4, Derived4>();
+
+    CheckNotDerivedFrom<Derived4, Base1>();
+    CheckNotDerivedFrom<Derived4, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived4, Derived1>();
+    CheckNotDerivedFrom<Derived4, Derived2>();
+    CheckNotDerivedFrom<Derived4, Derived3>();
+  }
+
+  { // Derived5 is the subject.
+    CheckDerivedFrom<Derived5, DerivedProtected>();
+    CheckDerivedFrom<Derived5, Derived4>();
+    CheckDerivedFrom<Derived5, Derived5>();
+
+    CheckNotDerivedFrom<Derived5, Base1>();
+    CheckNotDerivedFrom<Derived5, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived5, Derived1>();
+    CheckNotDerivedFrom<Derived5, Derived2>();
+    CheckNotDerivedFrom<Derived5, Derived3>();
+  }
+
+  return 0;
+}