path: root/chromium-127-clang17-traitors.patch

author: Andres Salomon <dilinger@debian.org>

Work around the following:

In file included from ../../mojo/public/cpp/bindings/lib/native_s:32
truct_serialization.cc:5:
In file included from ../../mojo/public/cpp/bindings/lib/native_struct_serialization.h:13:
In file included from ../../base/check_op.h:9:
In file included from /usr/bin/../include/c++/v1/string:545:
In file included from /usr/bin/../include/c++/v1/__functional/hash.h:24:
In file included from /usr/bin/../include/c++/v1/__utility/pair.h:16:
In file included from /usr/bin/../include/c++/v1/__fwd/get.h:16:
In file included from /usr/bin/../include/c++/v1/__fwd/subrange.h:20:
In file included from /usr/bin/../include/c++/v1/__iterator/concepts.h:34:
/usr/bin/../include/c++/v1/__memory/pointer_traits.h:118:22: error: implicit instantiation of undefined template 'std::__pointer_traits_element_type<IPC::MessageAttachment::Type, false>'
    typedef typename __pointer_traits_element_type<pointer>::type    element_type;
                     ^
../../base/types/to_address.h:32:40: note: in instantiation of template class 'std::pointer_traits<IPC::MessageAttachment::Type>' requested here
  requires requires(const P& p) { std::pointer_traits<P>::to_address(p); } ||
                                       ^
../../base/types/to_address.h:32:35: note: in instantiation of requirement here
../../mojo/public/cpp/bindings/lib/native_struct_serialization.cc  requires requires(const P& p) { std::pointer_traits<P>::to_address(p); } ||
                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../base/types/to_address.h:32:12: note: while substituting template arguments into constraint expression here
  requires requires(const P& p) { std::pointer_traits<P>::to_address(p); } ||
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../mojo/public/cpp/bindings/type_converter.h:103:26: note: while checking constraint satisfaction for template 'to_address<IPC::MessageAttachment::Type>' required here
    { mojo::ConvertTo<T>(base::to_address(obj)) } -> std::same_as<T>;
                         ^~~~


This turns out to be a clang-16 bug, fixed in clang-18:
https://github.com/llvm/llvm-project/issues/67449

This is just the pointer_traits.h header from libc++-18-dev,
with a minor tweak to get things building.

--- /dev/null
+++ b/__memory/pointer_traits.h
@@ -0,0 +1,245 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_POINTER_TRAITS_H
+#define _LIBCPP___MEMORY_POINTER_TRAITS_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_class.h>
+#include <__type_traits/is_function.h>
+#include <__type_traits/is_void.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class = void>
+struct __has_element_type : false_type {};
+
+template <class _Tp>
+struct __has_element_type<_Tp, __void_t<typename _Tp::element_type> > : true_type {};
+
+template <class _Ptr, bool = __has_element_type<_Ptr>::value>
+struct __pointer_traits_element_type {};
+
+template <class _Ptr>
+struct __pointer_traits_element_type<_Ptr, true> {
+  typedef _LIBCPP_NODEBUG typename _Ptr::element_type type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> {
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::element_type type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> {
+  typedef _LIBCPP_NODEBUG _Tp type;
+};
+
+template <class _Tp, class = void>
+struct __has_difference_type : false_type {};
+
+template <class _Tp>
+struct __has_difference_type<_Tp, __void_t<typename _Tp::difference_type> > : true_type {};
+
+template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
+struct __pointer_traits_difference_type {
+  typedef _LIBCPP_NODEBUG ptrdiff_t type;
+};
+
+template <class _Ptr>
+struct __pointer_traits_difference_type<_Ptr, true> {
+  typedef _LIBCPP_NODEBUG typename _Ptr::difference_type type;
+};
+
+template <class _Tp, class _Up>
+struct __has_rebind {
+private:
+  template <class _Xp>
+  static false_type __test(...);
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  template <class _Xp>
+  static true_type __test(typename _Xp::template rebind<_Up>* = 0);
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
+public:
+  static const bool value = decltype(__test<_Tp>(0))::value;
+};
+
+template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
+struct __pointer_traits_rebind {
+#ifndef _LIBCPP_CXX03_LANG
+  typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
+#else
+  typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up>::other type;
+#endif
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> {
+#ifndef _LIBCPP_CXX03_LANG
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
+#else
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
+#endif
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> {
+  typedef _Sp<_Up, _Args...> type;
+};
+
+template <class _Ptr, class = void>
+struct __pointer_traits_impl {};
+
+template <class _Ptr>
+struct __pointer_traits_impl<_Ptr, __void_t<typename __pointer_traits_element_type<_Ptr>::type> > {
+  typedef _Ptr pointer;
+  typedef typename __pointer_traits_element_type<pointer>::type element_type;
+  typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class _Up>
+  using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
+#else
+  template <class _Up>
+  struct rebind {
+    typedef typename __pointer_traits_rebind<pointer, _Up>::type other;
+  };
+#endif // _LIBCPP_CXX03_LANG
+
+private:
+  struct __nat {};
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) {
+    return pointer::pointer_to(__r);
+  }
+};
+
+template <class _Ptr>
+struct _LIBCPP_TEMPLATE_VIS pointer_traits : __pointer_traits_impl<_Ptr> {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*> {
+  typedef _Tp* pointer;
+  typedef _Tp element_type;
+  typedef ptrdiff_t difference_type;
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class _Up>
+  using rebind = _Up*;
+#else
+  template <class _Up>
+  struct rebind {
+    typedef _Up* other;
+  };
+#endif
+
+private:
+  struct __nat {};
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) _NOEXCEPT {
+    return std::addressof(__r);
+  }
+};
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _From, class _To>
+using __rebind_pointer_t = typename pointer_traits<_From>::template rebind<_To>;
+#else
+template <class _From, class _To>
+using __rebind_pointer_t = typename pointer_traits<_From>::template rebind<_To>::other;
+#endif
+
+// to_address
+
+template <class _Pointer, class = void>
+struct __to_address_helper;
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __to_address(_Tp* __p) _NOEXCEPT {
+  static_assert(!is_function<_Tp>::value, "_Tp is a function type");
+  return __p;
+}
+
+template <class _Pointer, class = void>
+struct _HasToAddress : false_type {};
+
+template <class _Pointer>
+struct _HasToAddress<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>())) >
+    : true_type {};
+
+template <class _Pointer, class = void>
+struct _HasArrow : false_type {};
+
+template <class _Pointer>
+struct _HasArrow<_Pointer, decltype((void)std::declval<const _Pointer&>().operator->()) > : true_type {};
+
+template <class _Pointer>
+struct _IsFancyPointer {
+  static const bool value = _HasArrow<_Pointer>::value || _HasToAddress<_Pointer>::value;
+};
+
+// enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
+template <class _Pointer, class = __enable_if_t< _And<is_class<_Pointer>, _IsFancyPointer<_Pointer> >::value > >
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+    decay_t<decltype(__to_address_helper<_Pointer>::__call(std::declval<const _Pointer&>()))>
+    __to_address(const _Pointer& __p) _NOEXCEPT {
+  return __to_address_helper<_Pointer>::__call(__p);
+}
+
+template <class _Pointer, class>
+struct __to_address_helper {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static decltype(std::__to_address(
+      std::declval<const _Pointer&>().operator->()))
+  __call(const _Pointer& __p) _NOEXCEPT {
+    return std::__to_address(__p.operator->());
+  }
+};
+
+template <class _Pointer>
+struct __to_address_helper<_Pointer,
+                           decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static decltype(pointer_traits<_Pointer>::to_address(
+      std::declval<const _Pointer&>()))
+  __call(const _Pointer& __p) _NOEXCEPT {
+    return pointer_traits<_Pointer>::to_address(__p);
+  }
+};
+
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto to_address(_Tp* __p) noexcept {
+  return std::__to_address(__p);
+}
+
+template <class _Pointer>
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto to_address(const _Pointer& __p) noexcept
+    -> decltype(std::__to_address(__p)) {
+  return std::__to_address(__p);
+}
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_POINTER_TRAITS_H