[libcxx] adds concept `std::common_with`

[cjdb]

Summary

Implements parts of:

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

Depends on D96660

[miscco]

libcxx/test/std/concepts/lang/common.compile.pass.cpp

287

I would greatly prefer if we could give those types names that describe what we are checking rather than numbers where one has to read the source an the standard

[cjdb]

libcxx/test/std/concepts/lang/common.compile.pass.cpp

287

The interesting information is in all the CommonTypeXs. Tn really just facilitates the common types.

[cjdb]

rebases to activate CI

[ldionne]

libcxx/include/concepts

195

I see this follows the spec closely, but I'm curious to understand. Here, I would have expected the check to be:

common_reference_with<
    common_type_t<_Tp, _Up> const&,
    common_reference_t<
        const _Tp&,
        const _Up&>>;

instead (with add_lvalue_reference_t simplified naively for legibility). In other words, why are we looking for a common reference between the non-const common type and the common-ref between the const-qualified types? I'm sure that'll highlight a misunderstanding I have about the concept.

libcxx/test/std/concepts/lang/common.compile.pass.cpp

19

Same comment about testing with static_assert(std::common_with<T, U&> == std::common_with<T, U>) as in the other patch, if you think it makes sense.

257

I'm not sure I follow this. Can you explain?

[cjdb]

applies some feedback

libcxx/include/concepts

195

In other words, why are we looking for a common reference between the non-const common type and the common-ref between the const-qualified types?

This asks the question "does common_type_t<T, U>& have a reference in common with common_reference_t<T const&, U const&>?" common_reference_t<T const&, U const&> should fall out as a reference-to-const unless basic_common_reference dictates otherwise, so it's essentially checking something to the effect of common_reference_with<CT&, CR const&>.

As for why this is the case, it screams proxy types to me (you wouldn't notice that unless you've played with zip_view). This is about as far as my knowledge goes though.

@CaseyCarter will probably correct me here, but getting stuff wrong on the Internet is how one learns?

libcxx/test/std/concepts/lang/common.compile.pass.cpp

19

Yep!

287

T8 and T9 were respectively renamed to CommonWithInt and CommonWithIntButRefLong, but I'm still not convinced about T1 through T7 (for now!)

[ldionne]

LGTM except nitpick about formatting in the tests. No need to wait for my re-review.

libcxx/include/concepts

195

I'm still curious to know the answer to this (@CaseyCarter maybe?), but this shouldn't hold up the review.

libcxx/test/std/concepts/lang/common.compile.pass.cpp

528–538

I think these specializations would be glance over if you disregarded clang-format and defined them on a single line like

...
template <> struct common_type<T7&, int&> { using type = void; };
...

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

libcxx/include/concepts

 
 // [concept.commonref]
 template<class _Tp, class _Up>
 concept common_reference_with =
   same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
   convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
   convertible_to<_Up, common_reference_t<_Tp, _Up>>;
 
+// [concept.common]
+template<class _Tp, class _Up>
+concept common_with =
+  same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+  requires {
+    static_cast<common_type_t<_Tp, _Up>>(_VSTD::declval<_Tp>());
+    static_cast<common_type_t<_Tp, _Up>>(_VSTD::declval<_Up>());
+  } &&
+  common_reference_with<
+    add_lvalue_reference_t<const _Tp>,
+    add_lvalue_reference_t<const _Up>> &&
+  common_reference_with<
+    add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+    common_reference_t<
+      add_lvalue_reference_t<const _Tp>,
+      add_lvalue_reference_t<const _Up>>>;
+
 // [concepts.arithmetic], arithmetic concepts
 template<class _Tp>
 concept integral = is_integral_v<_Tp>;
 
 template<class _Tp>
 concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
 
 template<class _Tp>

libcxx/test/std/concepts/lang/common.compile.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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class From, class To>
+// concept common_with;
+
+#include <concepts>
+
+template <class T, class U>
+constexpr bool CheckCommonWith() noexcept {
+  static_assert(std::common_with<T, U&>);
+  static_assert(std::common_with<T, const U&>);
+  static_assert(std::common_with<T, volatile U&>);
+  static_assert(std::common_with<T, const volatile U&>);
+  static_assert(std::common_with<T, U&&>);
+  static_assert(std::common_with<T, const U&&>);
+  static_assert(std::common_with<T, volatile U&&>);
+  static_assert(std::common_with<T, const volatile U&&>);
+  static_assert(std::common_with<T&, U&&>);
+  static_assert(std::common_with<T&, const U&&>);
+  static_assert(std::common_with<T&, volatile U&&>);
+  static_assert(std::common_with<T&, const volatile U&&>);
+  static_assert(std::common_with<const T&, U&&>);
+  static_assert(std::common_with<const T&, const U&&>);
+  static_assert(std::common_with<const T&, volatile U&&>);
+  static_assert(std::common_with<const T&, const volatile U&&>);
+  static_assert(std::common_with<volatile T&, U&&>);
+  static_assert(std::common_with<volatile T&, const U&&>);
+  static_assert(std::common_with<volatile T&, volatile U&&>);
+  static_assert(std::common_with<volatile T&, const volatile U&&>);
+  static_assert(std::common_with<const volatile T&, U&&>);
+  static_assert(std::common_with<const volatile T&, const U&&>);
+  static_assert(std::common_with<const volatile T&, volatile U&&>);
+  static_assert(std::common_with<const volatile T&, const volatile U&&>);
+
+  return std::common_with<T, U>;
+}
+
+template <class T, class U>
+constexpr bool HasValidCommonType() noexcept {
+  return requires { typename std::common_type_t<T, U>; }
+  &&std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T> >;
+}
+
+namespace BuiltinTypes {
+// fundamental types
+static_assert(std::common_with<void, void>);
+static_assert(CheckCommonWith<int, int>());
+static_assert(CheckCommonWith<int, long>());
+static_assert(CheckCommonWith<int, unsigned char>());
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(CheckCommonWith<int, __int128_t>());
+#endif
+static_assert(CheckCommonWith<int, double>());
+
+// arrays
+static_assert(CheckCommonWith<int[5], int[5]>());
+
+// pointers
+static_assert(CheckCommonWith<int*, int*>());
+static_assert(CheckCommonWith<int*, const int*>());
+static_assert(CheckCommonWith<int*, volatile int*>());
+static_assert(CheckCommonWith<int*, const volatile int*>());
+static_assert(CheckCommonWith<const int*, const int*>());
+static_assert(CheckCommonWith<const int*, volatile int*>());
+static_assert(CheckCommonWith<const int*, const volatile int*>());
+static_assert(CheckCommonWith<volatile int*, const int*>());
+static_assert(CheckCommonWith<volatile int*, volatile int*>());
+static_assert(CheckCommonWith<volatile int*, const volatile int*>());
+static_assert(CheckCommonWith<const volatile int*, const int*>());
+static_assert(CheckCommonWith<const volatile int*, volatile int*>());
+static_assert(CheckCommonWith<const volatile int*, const volatile int*>());
+
+static_assert(CheckCommonWith<int (*)(), int (*)()>());
+static_assert(CheckCommonWith<int (*)(), int (*)() noexcept>());
+static_assert(CheckCommonWith<int (&)(), int (&)()>());
+static_assert(CheckCommonWith<int (&)(), int (&)() noexcept>());
+static_assert(CheckCommonWith<int (&)(), int (*)()>());
+static_assert(CheckCommonWith<int (&)(), int (*)() noexcept>());
+
+struct S {};
+static_assert(CheckCommonWith<int S::*, int S::*>());
+static_assert(CheckCommonWith<int S::*, const int S::*>());
+static_assert(CheckCommonWith<int (S::*)(), int (S::*)()>());
+static_assert(CheckCommonWith<int (S::*)(), int (S::*)() noexcept>());
+static_assert(CheckCommonWith<int (S::*)() const, int (S::*)() const>());
+static_assert(
+    CheckCommonWith<int (S::*)() const, int (S::*)() const noexcept>());
+static_assert(CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(
+    CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile noexcept>());
+static_assert(CheckCommonWith<int (S::*)() const volatile,
+                              int (S::*)() const volatile>());
+static_assert(CheckCommonWith<int (S::*)() const volatile,
+                              int (S::*)() const volatile noexcept>());
+
+// nonsense
+static_assert(!std::common_with<double, float*>);
+static_assert(!std::common_with<int, int[5]>);
+static_assert(!std::common_with<int*, long*>);
+static_assert(!std::common_with<int*, unsigned int*>);
+static_assert(!std::common_with<int (*)(), int (*)(int)>);
+static_assert(!std::common_with<int S::*, float S::*>);
+static_assert(!std::common_with<int (S::*)(), int (S::*)() const>);
+static_assert(!std::common_with<int (S::*)(), int (S::*)() volatile>);
+static_assert(!std::common_with<int (S::*)(), int (S::*)() const volatile>);
+static_assert(!std::common_with<int (S::*)() const, int (S::*)() volatile>);
+static_assert(
+    !std::common_with<int (S::*)() const, int (S::*)() const volatile>);
+static_assert(
+    !std::common_with<int (S::*)() volatile, int (S::*)() const volatile>);
+} // namespace BuiltinTypes
+
+namespace NoDefaultCommonType {
+class T {};
+
+static_assert(!std::common_with<T, int>);
+static_assert(!std::common_with<int, T>);
+static_assert(!std::common_with<T, int[10]>);
+static_assert(!std::common_with<T[10], int>);
+static_assert(!std::common_with<T*, int*>);
+static_assert(!std::common_with<T*, const int*>);
+static_assert(!std::common_with<T*, volatile int*>);
+static_assert(!std::common_with<T*, const volatile int*>);
+static_assert(!std::common_with<const T*, int*>);
+static_assert(!std::common_with<volatile T*, int*>);
+static_assert(!std::common_with<const volatile T*, int*>);
+static_assert(!std::common_with<const T*, const int*>);
+static_assert(!std::common_with<const T*, volatile int*>);
+static_assert(!std::common_with<const T*, const volatile int*>);
+static_assert(!std::common_with<const T*, const int*>);
+static_assert(!std::common_with<volatile T*, const int*>);
+static_assert(!std::common_with<const volatile T*, const int*>);
+static_assert(!std::common_with<volatile T*, const int*>);
+static_assert(!std::common_with<volatile T*, volatile int*>);
+static_assert(!std::common_with<volatile T*, const volatile int*>);
+static_assert(!std::common_with<const T*, volatile int*>);
+static_assert(!std::common_with<volatile T*, volatile int*>);
+static_assert(!std::common_with<const volatile T*, volatile int*>);
+static_assert(!std::common_with<const volatile T*, const int*>);
+static_assert(!std::common_with<const volatile T*, volatile int*>);
+static_assert(!std::common_with<const volatile T*, const volatile int*>);
+static_assert(!std::common_with<const T*, const volatile int*>);
+static_assert(!std::common_with<volatile T*, const volatile int*>);
+static_assert(!std::common_with<const volatile T*, const volatile int*>);
+static_assert(!std::common_with<T&, int&>);
+static_assert(!std::common_with<T&, const int&>);
+static_assert(!std::common_with<T&, volatile int&>);
+static_assert(!std::common_with<T&, const volatile int&>);
+static_assert(!std::common_with<const T&, int&>);
+static_assert(!std::common_with<volatile T&, int&>);
+static_assert(!std::common_with<const volatile T&, int&>);
+static_assert(!std::common_with<const T&, const int&>);
+static_assert(!std::common_with<const T&, volatile int&>);
+static_assert(!std::common_with<const T&, const volatile int&>);
+static_assert(!std::common_with<const T&, const int&>);
+static_assert(!std::common_with<volatile T&, const int&>);
+static_assert(!std::common_with<const volatile T&, const int&>);
+static_assert(!std::common_with<volatile T&, const int&>);
+static_assert(!std::common_with<volatile T&, volatile int&>);
+static_assert(!std::common_with<volatile T&, const volatile int&>);
+static_assert(!std::common_with<const T&, volatile int&>);
+static_assert(!std::common_with<volatile T&, volatile int&>);
+static_assert(!std::common_with<const volatile T&, volatile int&>);
+static_assert(!std::common_with<const volatile T&, const int&>);
+static_assert(!std::common_with<const volatile T&, volatile int&>);
+static_assert(!std::common_with<const volatile T&, const volatile int&>);
+static_assert(!std::common_with<const T&, const volatile int&>);
+static_assert(!std::common_with<volatile T&, const volatile int&>);
+static_assert(!std::common_with<const volatile T&, const volatile int&>);
+static_assert(!std::common_with<T&, int&&>);
+static_assert(!std::common_with<T&, const int&&>);
+static_assert(!std::common_with<T&, volatile int&&>);
+static_assert(!std::common_with<T&, const volatile int&&>);
+static_assert(!std::common_with<const T&, int&&>);
+static_assert(!std::common_with<volatile T&, int&&>);
+static_assert(!std::common_with<const volatile T&, int&&>);
+static_assert(!std::common_with<const T&, const int&&>);
+static_assert(!std::common_with<const T&, volatile int&&>);
+static_assert(!std::common_with<const T&, const volatile int&&>);
+static_assert(!std::common_with<const T&, const int&&>);
+static_assert(!std::common_with<volatile T&, const int&&>);
+static_assert(!std::common_with<const volatile T&, const int&&>);
+static_assert(!std::common_with<volatile T&, const int&&>);
+static_assert(!std::common_with<volatile T&, volatile int&&>);
+static_assert(!std::common_with<volatile T&, const volatile int&&>);
+static_assert(!std::common_with<const T&, volatile int&&>);
+static_assert(!std::common_with<volatile T&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&, const int&&>);
+static_assert(!std::common_with<const volatile T&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&, const volatile int&&>);
+static_assert(!std::common_with<const T&, const volatile int&&>);
+static_assert(!std::common_with<volatile T&, const volatile int&&>);
+static_assert(!std::common_with<const volatile T&, const volatile int&&>);
+static_assert(!std::common_with<T&&, int&>);
+static_assert(!std::common_with<T&&, const int&>);
+static_assert(!std::common_with<T&&, volatile int&>);
+static_assert(!std::common_with<T&&, const volatile int&>);
+static_assert(!std::common_with<const T&&, int&>);
+static_assert(!std::common_with<volatile T&&, int&>);
+static_assert(!std::common_with<const volatile T&&, int&>);
+static_assert(!std::common_with<const T&&, const int&>);
+static_assert(!std::common_with<const T&&, volatile int&>);
+static_assert(!std::common_with<const T&&, const volatile int&>);
+static_assert(!std::common_with<const T&&, const int&>);
+static_assert(!std::common_with<volatile T&&, const int&>);
+static_assert(!std::common_with<const volatile T&&, const int&>);
+static_assert(!std::common_with<volatile T&&, const int&>);
+static_assert(!std::common_with<volatile T&&, volatile int&>);
+static_assert(!std::common_with<volatile T&&, const volatile int&>);
+static_assert(!std::common_with<const T&&, volatile int&>);
+static_assert(!std::common_with<volatile T&&, volatile int&>);
+static_assert(!std::common_with<const volatile T&&, volatile int&>);
+static_assert(!std::common_with<const volatile T&&, const int&>);
+static_assert(!std::common_with<const volatile T&&, volatile int&>);
+static_assert(!std::common_with<const volatile T&&, const volatile int&>);
+static_assert(!std::common_with<const T&&, const volatile int&>);
+static_assert(!std::common_with<volatile T&&, const volatile int&>);
+static_assert(!std::common_with<const volatile T&&, const volatile int&>);
+static_assert(!std::common_with<T&&, int&&>);
+static_assert(!std::common_with<T&&, const int&&>);
+static_assert(!std::common_with<T&&, volatile int&&>);
+static_assert(!std::common_with<T&&, const volatile int&&>);
+static_assert(!std::common_with<const T&&, int&&>);
+static_assert(!std::common_with<volatile T&&, int&&>);
+static_assert(!std::common_with<const volatile T&&, int&&>);
+static_assert(!std::common_with<const T&&, const int&&>);
+static_assert(!std::common_with<const T&&, volatile int&&>);
+static_assert(!std::common_with<const T&&, const volatile int&&>);
+static_assert(!std::common_with<const T&&, const int&&>);
+static_assert(!std::common_with<volatile T&&, const int&&>);
+static_assert(!std::common_with<const volatile T&&, const int&&>);
+static_assert(!std::common_with<volatile T&&, const int&&>);
+static_assert(!std::common_with<volatile T&&, volatile int&&>);
+static_assert(!std::common_with<volatile T&&, const volatile int&&>);
+static_assert(!std::common_with<const T&&, volatile int&&>);
+static_assert(!std::common_with<volatile T&&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&&, const int&&>);
+static_assert(!std::common_with<const volatile T&&, volatile int&&>);
+static_assert(!std::common_with<const volatile T&&, const volatile int&&>);
+static_assert(!std::common_with<const T&&, const volatile int&&>);
+static_assert(!std::common_with<volatile T&&, const volatile int&&>);
+static_assert(!std::common_with<const volatile T&&, const volatile int&&>);
+} // namespace NoDefaultCommonType
+
+struct BadBasicCommonType {
+  // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
+  // In the meantime, the test should be included. If compiler support is added, then an include guard
+  // should be placed so the test doesn't get deleted.
+};
+
+namespace std {
+template <>
+struct common_type<BadBasicCommonType, int> {
+  using type = BadBasicCommonType;
+};
+
+template <>
+struct common_type<int, BadBasicCommonType> {
+  using type = int;
+};
+} // namespace std
+static_assert(requires {
+  typename std::common_type_t<BadBasicCommonType, int>;
+});
+static_assert(requires {
+  typename std::common_type_t<int, BadBasicCommonType>;
+});
+static_assert(!std::same_as<std::common_type_t<BadBasicCommonType, int>,
+                            std::common_type_t<int, BadBasicCommonType> >);
+static_assert(!std::common_with<BadBasicCommonType, int>);
+
+struct DullCommonType {};
+static_assert(!std::convertible_to<DullCommonType, int>);
+
+struct T1 {};
+static_assert(!std::convertible_to<DullCommonType, T1>);
+
+namespace std {
+template <>
+struct common_type<T1, int> {
+  using type = DullCommonType;
+};
+
+template <>
+struct common_type<int, T1> {
+  using type = DullCommonType;
+};
+} // namespace std
+static_assert(HasValidCommonType<T1, int>());
+static_assert(!std::common_with<T1, int>);
+
+struct CommonTypeImplicitlyConstructibleFromInt {
+  explicit(false) CommonTypeImplicitlyConstructibleFromInt(int);
+};
+static_assert(requires {
+  static_cast<CommonTypeImplicitlyConstructibleFromInt>(0);
+});
+
+struct T2 {};
+static_assert(
+    !std::convertible_to<CommonTypeImplicitlyConstructibleFromInt, T2>);
+
+namespace std {
+template <>
+struct common_type<T2, int> {
+  using type = CommonTypeImplicitlyConstructibleFromInt;
+};
+
+template <>
+struct common_type<int, T2> {
+  using type = CommonTypeImplicitlyConstructibleFromInt;
+};
+} // namespace std
+static_assert(HasValidCommonType<T2, int>());
+static_assert(!std::common_with<T2, int>);
+
+struct CommonTypeExplicitlyConstructibleFromInt {
+  explicit CommonTypeExplicitlyConstructibleFromInt(int);
+};
+static_assert(requires {
+  static_cast<CommonTypeExplicitlyConstructibleFromInt>(0);
+});
+
+struct T3 {};
+static_assert(
+    !std::convertible_to<CommonTypeExplicitlyConstructibleFromInt, T2>);
+
+namespace std {
+template <>
+struct common_type<T3, int> {
+  using type = CommonTypeExplicitlyConstructibleFromInt;
+};
+
+template <>
+struct common_type<int, T3> {
+  using type = CommonTypeExplicitlyConstructibleFromInt;
+};
+} // namespace std
+static_assert(HasValidCommonType<T3, int>());
+static_assert(!std::common_with<T3, int>);
+
+struct T4 {};
+struct CommonTypeImplicitlyConstructibleFromT4 {
+  explicit(false) CommonTypeImplicitlyConstructibleFromT4(T4);
+};
+static_assert(requires(T4 t4) {
+  static_cast<CommonTypeImplicitlyConstructibleFromT4>(t4);
+});
+
+namespace std {
+template <>
+struct common_type<T4, int> {
+  using type = CommonTypeImplicitlyConstructibleFromT4;
+};
+
+template <>
+struct common_type<int, T4> {
+  using type = CommonTypeImplicitlyConstructibleFromT4;
+};
+} // namespace std
+static_assert(HasValidCommonType<T4, int>());
+static_assert(!std::common_with<T4, int>);
+
+struct T5 {};
+struct CommonTypeExplicitlyConstructibleFromT5 {
+  explicit CommonTypeExplicitlyConstructibleFromT5(T5);
+};
+static_assert(requires(T5 t5) {
+  static_cast<CommonTypeExplicitlyConstructibleFromT5>(t5);
+});
+
+namespace std {
+template <>
+struct common_type<T5, int> {
+  using type = CommonTypeExplicitlyConstructibleFromT5;
+};
+
+template <>
+struct common_type<int, T5> {
+  using type = CommonTypeExplicitlyConstructibleFromT5;
+};
+} // namespace std
+static_assert(HasValidCommonType<T5, int>());
+static_assert(!std::common_with<T5, int>);
+
+struct T6 {};
+struct CommonTypeNoCommonReference {
+  CommonTypeNoCommonReference(T6);
+  CommonTypeNoCommonReference(int);
+};
+
+namespace std {
+template <>
+struct common_type<T6, int> {
+  using type = CommonTypeNoCommonReference;
+};
+
+template <>
+struct common_type<int, T6> {
+  using type = CommonTypeNoCommonReference;
+};
+
+template <>
+struct common_type<const T6&, const int&> {};
+
+template <>
+struct common_type<const int&, const T6&> {};
+} // namespace std
+
+template <typename T, typename U>
+constexpr bool HasCommonReference() noexcept {
+  return requires { typename std::common_reference_t<T, U>; };
+}
+
+static_assert(HasValidCommonType<T6, int>());
+static_assert(!HasCommonReference<const T6&, const int&>());
+static_assert(!std::common_with<T6, int>);
+
+struct T7 {};
+struct CommonTypeNoMetaCommonReference {
+  CommonTypeNoMetaCommonReference(T7);
+  CommonTypeNoMetaCommonReference(int);
+};
+
+namespace std {
+template <>
+struct common_type<T7, int> {
+  using type = CommonTypeNoMetaCommonReference;
+};
+
+template <>
+struct common_type<int, T7> {
+  using type = CommonTypeNoMetaCommonReference;
+};
+
+template <>
+struct common_type<const T7&, const int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const int&, const T7&> {
+  using type = void;
+};
+} // namespace std
+static_assert(HasValidCommonType<T7, int>());
+static_assert(HasValidCommonType<const T7&, const int&>());
+static_assert(HasCommonReference<const T7&, const int&>());
+static_assert(
+    !HasCommonReference<std::common_type_t<T7, int>&,
+                        std::common_reference_t<const T7&, const int&> >());
+static_assert(!std::common_with<T7, int>);
+
+struct T8 {
+  operator int() const;
+};
+
+namespace std {
+template <>
+struct common_type<T8, int> {
+  using type = int;
+};
+
+template <>
+struct common_type<int, T8> {
+  using type = int;
+};
+} // namespace std
+static_assert(std::common_with<T8, int>);
+
+struct T9 {
+  operator int() const;
+};
+
+namespace std {
+template <>
+struct common_type<T9, int> {
+  using type = int;
+};
+
+template <>
+struct common_type<int, T9> {
+  using type = int;
+};
+
+template <>
+struct common_type<const T9&, const int&> {
+  using type = long;
+};
+
+template <>
+struct common_type<const int&, const T9&> {
+  using type = long;
+};
+} // namespace std
+static_assert(std::common_with<T9, int>);
+
+int main(int, char**) { return 0; }