Skip to content

[libc++] Simplify the implementation of __is_referenceable #130043

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 24, 2025
Merged

[libc++] Simplify the implementation of __is_referenceable #130043

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion libcxx/include/__type_traits/add_lvalue_reference.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ using __add_lvalue_reference_t _LIBCPP_NODEBUG = __add_lvalue_reference(_Tp);

#else

template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
template <class _Tp, bool = __is_referenceable_v<_Tp>>
struct __add_lvalue_reference_impl {
using type _LIBCPP_NODEBUG = _Tp;
};
Expand Down
2 changes: 1 addition & 1 deletion libcxx/include/__type_traits/add_pointer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ template <class _Tp>
using __add_pointer_t _LIBCPP_NODEBUG = __add_pointer(_Tp);

#else
template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
template <class _Tp, bool = __is_referenceable_v<_Tp> || is_void<_Tp>::value>
struct __add_pointer_impl {
using type _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tp>*;
};
Expand Down
2 changes: 1 addition & 1 deletion libcxx/include/__type_traits/add_rvalue_reference.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ using __add_rvalue_reference_t _LIBCPP_NODEBUG = __add_rvalue_reference(_Tp);

#else

template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
template <class _Tp, bool = __is_referenceable_v<_Tp> >
struct __add_rvalue_reference_impl {
using type _LIBCPP_NODEBUG = _Tp;
};
Expand Down
2 changes: 1 addition & 1 deletion libcxx/include/__type_traits/decay.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ struct _LIBCPP_TEMPLATE_VIS decay {
using _Up _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tp>;

public:
using type _LIBCPP_NODEBUG = typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type;
using type _LIBCPP_NODEBUG = typename __decay<_Up, __is_referenceable_v<_Up> >::type;
};

template <class _Tp>
Expand Down
20 changes: 4 additions & 16 deletions libcxx/include/__type_traits/is_referenceable.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,31 +10,19 @@
#define _LIBCPP___TYPE_TRAITS_IS_REFERENCEABLE_H

#include <__config>
#include <__type_traits/integral_constant.h>
#include <__type_traits/is_same.h>
#include <__type_traits/void_t.h>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif

_LIBCPP_BEGIN_NAMESPACE_STD

#if __has_builtin(__is_referenceable)
template <class _Tp>
struct __libcpp_is_referenceable : integral_constant<bool, __is_referenceable(_Tp)> {};
#else
struct __libcpp_is_referenceable_impl {
template <class _Tp>
static _Tp& __test(int);
template <class _Tp>
static false_type __test(...);
};
template <class _Tp, class = void>
inline const bool __is_referenceable_v = false;

template <class _Tp>
struct __libcpp_is_referenceable
: integral_constant<bool, _IsNotSame<decltype(__libcpp_is_referenceable_impl::__test<_Tp>(0)), false_type>::value> {
};
#endif // __has_builtin(__is_referenceable)
inline const bool __is_referenceable_v<_Tp, __void_t<_Tp&> > = true;

_LIBCPP_END_NAMESPACE_STD

Expand Down
192 changes: 192 additions & 0 deletions libcxx/test/libcxx/utilities/meta/is_referenceable.compile.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,192 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//

// __is_referenceable_v<Tp>
//
// [defns.referenceable] defines "a referenceable type" as:
// An object type, a function type that does not have cv-qualifiers
// or a ref-qualifier, or a reference type.
//

// XFAIL: FROZEN-CXX03-HEADERS-FIXME

#include <type_traits>
#include <cassert>

#include "test_macros.h"

struct Foo {};

static_assert((!std::__is_referenceable_v<void>), "");
static_assert((std::__is_referenceable_v<int>), "");
static_assert((std::__is_referenceable_v<int[3]>), "");
static_assert((std::__is_referenceable_v<int[]>), "");
static_assert((std::__is_referenceable_v<int&>), "");
static_assert((std::__is_referenceable_v<const int&>), "");
static_assert((std::__is_referenceable_v<int*>), "");
static_assert((std::__is_referenceable_v<const int*>), "");
static_assert((std::__is_referenceable_v<Foo>), "");
static_assert((std::__is_referenceable_v<const Foo>), "");
static_assert((std::__is_referenceable_v<Foo&>), "");
static_assert((std::__is_referenceable_v<const Foo&>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<Foo&&>), "");
static_assert((std::__is_referenceable_v<const Foo&&>), "");
#endif

static_assert((std::__is_referenceable_v<int __attribute__((__vector_size__(8)))>), "");
static_assert((std::__is_referenceable_v<const int __attribute__((__vector_size__(8)))>), "");
static_assert((std::__is_referenceable_v<float __attribute__((__vector_size__(16)))>), "");
static_assert((std::__is_referenceable_v<const float __attribute__((__vector_size__(16)))>), "");

// Functions without cv-qualifiers are referenceable
static_assert((std::__is_referenceable_v<void()>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void() const>), "");
static_assert((!std::__is_referenceable_v<void() &>), "");
static_assert((!std::__is_referenceable_v<void() const&>), "");
static_assert((!std::__is_referenceable_v<void() &&>), "");
static_assert((!std::__is_referenceable_v<void() const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int) const>), "");
static_assert((!std::__is_referenceable_v<void(int) &>), "");
static_assert((!std::__is_referenceable_v<void(int) const&>), "");
static_assert((!std::__is_referenceable_v<void(int) &&>), "");
static_assert((!std::__is_referenceable_v<void(int) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int, float)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int, float) const>), "");
static_assert((!std::__is_referenceable_v<void(int, float) &>), "");
static_assert((!std::__is_referenceable_v<void(int, float) const&>), "");
static_assert((!std::__is_referenceable_v<void(int, float) &&>), "");
static_assert((!std::__is_referenceable_v<void(int, float) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int, float, Foo&)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int, float, Foo&) const>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&) &>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&) const&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&) &&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(...)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(...) const>), "");
static_assert((!std::__is_referenceable_v<void(...) &>), "");
static_assert((!std::__is_referenceable_v<void(...) const&>), "");
static_assert((!std::__is_referenceable_v<void(...) &&>), "");
static_assert((!std::__is_referenceable_v<void(...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int, ...)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int, ...) const>), "");
static_assert((!std::__is_referenceable_v<void(int, ...) &>), "");
static_assert((!std::__is_referenceable_v<void(int, ...) const&>), "");
static_assert((!std::__is_referenceable_v<void(int, ...) &&>), "");
static_assert((!std::__is_referenceable_v<void(int, ...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int, float, ...)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int, float, ...) const>), "");
static_assert((!std::__is_referenceable_v<void(int, float, ...) &>), "");
static_assert((!std::__is_referenceable_v<void(int, float, ...) const&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, ...) &&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, ...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void(int, float, Foo&, ...)>), "");
#if TEST_STD_VER >= 11
static_assert((!std::__is_referenceable_v<void(int, float, Foo&, ...) const>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&, ...) &>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&, ...) const&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&, ...) &&>), "");
static_assert((!std::__is_referenceable_v<void(int, float, Foo&, ...) const&&>), "");
#endif

// member functions with or without cv-qualifiers are referenceable
static_assert((std::__is_referenceable_v<void (Foo::*)()>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)() const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)() &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)() const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)() &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)() const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int, float)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(...)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(...) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(...) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(...) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(...) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, ...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, ...) const&&>), "");
#endif

static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...)>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...) const>), "");
#if TEST_STD_VER >= 11
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...) &>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...) const&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...) &&>), "");
static_assert((std::__is_referenceable_v<void (Foo::*)(int, float, Foo&, ...) const&&>), "");
#endif
Loading