Skip to content
This repository has been archived by the owner on Apr 23, 2020. It is now read-only.

Commit

Permalink
Fix PR40495 - is_invokable_v<void> does not compile
Browse files Browse the repository at this point in the history 
The meta-programming that attempted to form the invoke call expression
was not in a SFINAE context. This made it a hard error to provide
non-referencable types like 'void' or 'void (...) const'.

This patch fixes the error by checking the validity of the call
expression within a SFINAE context.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352522 91177308-0d34-0410-b5e6-96231b3b80d8
  • Loading branch information
@EricWF
EricWF committed Jan 29, 2019
1 parent e0324cb commit a32a775
Show file tree
Hide file tree
Showing 3 changed files with 376 additions and 199 deletions.
37 changes: 20 additions & 17 deletions include/type_traits
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4360,28 +4360,31 @@ _LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)
#undef _LIBCPP_INVOKE_RETURN

// __invokable

template <class _Ret, class _Fp, class ..._Args>
struct __invokable_r
{
// FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
// or incomplete array types as required by the standard.
using _Result = decltype(
_VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
template <class _XFp, class ..._XArgs>
static auto __try_call(int) -> decltype(
_VSTD::__invoke(_VSTD::declval<_XFp>(), _VSTD::declval<_XArgs>()...));
template <class _XFp, class ..._XArgs>
static __nat __try_call(...);

using type =
typename conditional<
!is_same<_Result, __nat>::value,
typename conditional<
is_void<_Ret>::value,
true_type,
is_convertible<_Result, _Ret>
>::type,
false_type
>::type;
static const bool value = type::value;
};
// FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
// or incomplete array types as required by the standard.
using _Result = decltype(__try_call<_Fp, _Args...>(0));

using type =
typename conditional<
!is_same<_Result, __nat>::value,
typename conditional<
is_void<_Ret>::value,
true_type,
is_convertible<_Result, _Ret>
>::type,
false_type
>::type;
static const bool value = type::value;
};
template <class _Fp, class ..._Args>
using __invokable = __invokable_r<void, _Fp, _Args...>;

Expand Down
305 changes: 192 additions & 113 deletions test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,9 +15,13 @@
// Most testing of is_invocable is done within the [meta.trans.other] result_of
// tests.

// Fn and all types in the template parameter pack ArgTypes shall be
// complete types, cv void, or arrays of unknown bound.

#include <type_traits>
#include <functional>
#include <memory>
#include <vector>

#include "test_macros.h"

Expand All @@ -37,129 +41,204 @@ struct NotCallableWithInt {
int operator()(Tag) { return 42; }
};

int main()
{
struct Sink {
template <class ...Args>
void operator()(Args&&...) const {}
};

int main() {
using AbominableFunc = void(...) const;

// Non-callable things
{
static_assert(!std::is_invocable<void>::value, "");
static_assert(!std::is_invocable<const void>::value, "");
static_assert(!std::is_invocable<volatile void>::value, "");
static_assert(!std::is_invocable<const volatile void>::value, "");
static_assert(!std::is_invocable<std::nullptr_t>::value, "");
static_assert(!std::is_invocable<int>::value, "");
static_assert(!std::is_invocable<double>::value, "");

static_assert(!std::is_invocable<int[]>::value, "");
static_assert(!std::is_invocable<int[3]>::value, "");

static_assert(!std::is_invocable<int*>::value, "");
static_assert(!std::is_invocable<const int*>::value, "");
static_assert(!std::is_invocable<int const*>::value, "");

static_assert(!std::is_invocable<int&>::value, "");
static_assert(!std::is_invocable<const int&>::value, "");
static_assert(!std::is_invocable<int&&>::value, "");

static_assert(!std::is_invocable<std::vector<int> >::value, "");
static_assert(!std::is_invocable<std::vector<int*> >::value, "");
static_assert(!std::is_invocable<std::vector<int**> >::value, "");

static_assert(!std::is_invocable<AbominableFunc>::value, "");

// with parameters
static_assert(!std::is_invocable<int, int>::value, "");
static_assert(!std::is_invocable<int, double, float>::value, "");
static_assert(!std::is_invocable<int, char, float, double>::value, "");
static_assert(!std::is_invocable<Sink, AbominableFunc>::value, "");
static_assert(!std::is_invocable<Sink, void>::value, "");
static_assert(!std::is_invocable<Sink, const volatile void>::value,
"");


static_assert(!std::is_invocable_r<int, void>::value, "");
static_assert(!std::is_invocable_r<int, const void>::value, "");
static_assert(!std::is_invocable_r<int, volatile void>::value, "");
static_assert(!std::is_invocable_r<int, const volatile void>::value, "");
static_assert(!std::is_invocable_r<int, std::nullptr_t>::value, "");
static_assert(!std::is_invocable_r<int, int>::value, "");
static_assert(!std::is_invocable_r<int, double>::value, "");

static_assert(!std::is_invocable_r<int, int[]>::value, "");
static_assert(!std::is_invocable_r<int, int[3]>::value, "");

static_assert(!std::is_invocable_r<int, int*>::value, "");
static_assert(!std::is_invocable_r<int, const int*>::value, "");
static_assert(!std::is_invocable_r<int, int const*>::value, "");

static_assert(!std::is_invocable_r<int, int&>::value, "");
static_assert(!std::is_invocable_r<int, const int&>::value, "");
static_assert(!std::is_invocable_r<int, int&&>::value, "");

static_assert(!std::is_invocable_r<int, std::vector<int> >::value, "");
static_assert(!std::is_invocable_r<int, std::vector<int*> >::value, "");
static_assert(!std::is_invocable_r<int, std::vector<int**> >::value, "");
static_assert(!std::is_invocable_r<void, AbominableFunc>::value, "");

// with parameters
static_assert(!std::is_invocable_r<int, int, int>::value, "");
static_assert(!std::is_invocable_r<int, int, double, float>::value, "");
static_assert(!std::is_invocable_r<int, int, char, float, double>::value,
"");
static_assert(!std::is_invocable_r<void, Sink, AbominableFunc>::value, "");
static_assert(!std::is_invocable_r<void, Sink, void>::value, "");
static_assert(!std::is_invocable_r<void, Sink, const volatile void>::value,
"");
}
{
using Fn = int (Tag::*)(int);
using RFn = int (Tag::*)(int)&&;
// INVOKE bullet 1, 2 and 3
{
using Fn = int(Tag::*)(int);
using RFn = int(Tag::*)(int) &&;
// INVOKE bullet 1, 2 and 3
{
// Bullet 1
static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
static_assert(!std::is_invocable<Fn, Tag&>::value, "");
static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
}
{
// Bullet 2
using T = std::reference_wrapper<Tag>;
using DT = std::reference_wrapper<DerFromTag>;
using CT = std::reference_wrapper<const Tag>;
static_assert(std::is_invocable<Fn, T&, int>::value, "");
static_assert(std::is_invocable<Fn, DT&, int>::value, "");
static_assert(std::is_invocable<Fn, const T&, int>::value, "");
static_assert(std::is_invocable<Fn, T&&, int>::value, "");
static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
static_assert(!std::is_invocable<RFn, T, int>::value, "");
}
{
// Bullet 3
using T = Tag*;
using DT = DerFromTag*;
using CT = const Tag*;
using ST = std::unique_ptr<Tag>;
static_assert(std::is_invocable<Fn, T&, int>::value, "");
static_assert(std::is_invocable<Fn, DT&, int>::value, "");
static_assert(std::is_invocable<Fn, const T&, int>::value, "");
static_assert(std::is_invocable<Fn, T&&, int>::value, "");
static_assert(std::is_invocable<Fn, ST, int>::value, "");
static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
static_assert(!std::is_invocable<RFn, T, int>::value, "");
}
// Bullet 1
static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
static_assert(!std::is_invocable<Fn, Tag&>::value, "");
static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
}
{
// Bullets 4, 5 and 6
using Fn = int (Tag::*);
static_assert(!std::is_invocable<Fn>::value, "");
{
// Bullet 4
static_assert(std::is_invocable<Fn, Tag&>::value, "");
static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
static_assert(std::is_invocable<Fn, Tag&&>::value, "");
static_assert(std::is_invocable<Fn, Tag const&>::value, "");
}
{
// Bullet 5
using T = std::reference_wrapper<Tag>;
using DT = std::reference_wrapper<DerFromTag>;
using CT = std::reference_wrapper<const Tag>;
static_assert(std::is_invocable<Fn, T&>::value, "");
static_assert(std::is_invocable<Fn, DT&>::value, "");
static_assert(std::is_invocable<Fn, const T&>::value, "");
static_assert(std::is_invocable<Fn, T&&>::value, "");
static_assert(std::is_invocable<Fn, CT&>::value, "");
}
{
// Bullet 6
using T = Tag*;
using DT = DerFromTag*;
using CT = const Tag*;
using ST = std::unique_ptr<Tag>;
static_assert(std::is_invocable<Fn, T&>::value, "");
static_assert(std::is_invocable<Fn, DT&>::value, "");
static_assert(std::is_invocable<Fn, const T&>::value, "");
static_assert(std::is_invocable<Fn, T&&>::value, "");
static_assert(std::is_invocable<Fn, ST>::value, "");
static_assert(std::is_invocable<Fn, CT&>::value, "");
}
// Bullet 2
using T = std::reference_wrapper<Tag>;
using DT = std::reference_wrapper<DerFromTag>;
using CT = std::reference_wrapper<const Tag>;
static_assert(std::is_invocable<Fn, T&, int>::value, "");
static_assert(std::is_invocable<Fn, DT&, int>::value, "");
static_assert(std::is_invocable<Fn, const T&, int>::value, "");
static_assert(std::is_invocable<Fn, T&&, int>::value, "");
static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
static_assert(!std::is_invocable<RFn, T, int>::value, "");
}
{
// INVOKE bullet 7
{
// Function pointer
using Fp = void(*)(Tag&, int);
static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
static_assert(!std::is_invocable<Fp>::value, "");
static_assert(!std::is_invocable<Fp, Tag&>::value, "");
}
{
// Function reference
using Fp = void(&)(Tag&, int);
static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
static_assert(!std::is_invocable<Fp>::value, "");
static_assert(!std::is_invocable<Fp, Tag&>::value, "");
}
{
// Function object
using Fn = NotCallableWithInt;
static_assert(std::is_invocable<Fn, Tag>::value, "");
static_assert(!std::is_invocable<Fn, int>::value, "");
}
// Bullet 3
using T = Tag*;
using DT = DerFromTag*;
using CT = const Tag*;
using ST = std::unique_ptr<Tag>;
static_assert(std::is_invocable<Fn, T&, int>::value, "");
static_assert(std::is_invocable<Fn, DT&, int>::value, "");
static_assert(std::is_invocable<Fn, const T&, int>::value, "");
static_assert(std::is_invocable<Fn, T&&, int>::value, "");
static_assert(std::is_invocable<Fn, ST, int>::value, "");
static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
static_assert(!std::is_invocable<RFn, T, int>::value, "");
}
}
{
// Bullets 4, 5 and 6
using Fn = int(Tag::*);
static_assert(!std::is_invocable<Fn>::value, "");
{
// Check that the conversion to the return type is properly checked
using Fn = int(*)();
static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
static_assert(std::is_invocable_r<double, Fn>::value, "");
static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
// Bullet 4
static_assert(std::is_invocable<Fn, Tag&>::value, "");
static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
static_assert(std::is_invocable<Fn, Tag&&>::value, "");
static_assert(std::is_invocable<Fn, Tag const&>::value, "");
}
{
// Check for is_invocable_v
using Fn = void(*)();
static_assert(std::is_invocable_v<Fn>, "");
static_assert(!std::is_invocable_v<Fn, int>, "");
// Bullet 5
using T = std::reference_wrapper<Tag>;
using DT = std::reference_wrapper<DerFromTag>;
using CT = std::reference_wrapper<const Tag>;
static_assert(std::is_invocable<Fn, T&>::value, "");
static_assert(std::is_invocable<Fn, DT&>::value, "");
static_assert(std::is_invocable<Fn, const T&>::value, "");
static_assert(std::is_invocable<Fn, T&&>::value, "");
static_assert(std::is_invocable<Fn, CT&>::value, "");
}
{
// Check for is_invocable_r_v
using Fn = void(*)();
static_assert(std::is_invocable_r_v<void, Fn>, "");
static_assert(!std::is_invocable_r_v<int, Fn>, "");
// Bullet 6
using T = Tag*;
using DT = DerFromTag*;
using CT = const Tag*;
using ST = std::unique_ptr<Tag>;
static_assert(std::is_invocable<Fn, T&>::value, "");
static_assert(std::is_invocable<Fn, DT&>::value, "");
static_assert(std::is_invocable<Fn, const T&>::value, "");
static_assert(std::is_invocable<Fn, T&&>::value, "");
static_assert(std::is_invocable<Fn, ST>::value, "");
static_assert(std::is_invocable<Fn, CT&>::value, "");
}
}
{ // INVOKE bullet 7
{// Function pointer
using Fp = void(*)(Tag&, int);
static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
static_assert(!std::is_invocable<Fp>::value, "");
static_assert(!std::is_invocable<Fp, Tag&>::value, "");
}
{
// Function reference
using Fp = void (&)(Tag&, int);
static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
static_assert(!std::is_invocable<Fp>::value, "");
static_assert(!std::is_invocable<Fp, Tag&>::value, "");
}
{
// Function object
using Fn = NotCallableWithInt;
static_assert(std::is_invocable<Fn, Tag>::value, "");
static_assert(!std::is_invocable<Fn, int>::value, "");
}
}
{
// Check that the conversion to the return type is properly checked
using Fn = int (*)();
static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
static_assert(std::is_invocable_r<double, Fn>::value, "");
static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
}
{
// Check for is_invocable_v
using Fn = void (*)();
static_assert(std::is_invocable_v<Fn>, "");
static_assert(!std::is_invocable_v<Fn, int>, "");
}
{
// Check for is_invocable_r_v
using Fn = void (*)();
static_assert(std::is_invocable_r_v<void, Fn>, "");
static_assert(!std::is_invocable_r_v<int, Fn>, "");
}
}
Loading

0 comments on commit a32a775

Please sign in to comment.