libstdc++-v3/testsuite/20_util/result_of/sfinae_friendly_1.cc

// { dg-do compile { target c++11 } }
// { dg-additional-options "-Wno-volatile" { target c++2a } }

// Copyright (C) 2012-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.

#include <memory>
#include <cstddef>
#include <type_traits>

// Uncomment the following define once gcc has fixed bug 52748
// (incomplete types in function call expressions):
#define HAS_52748_FIXED

// Helper types:
struct has_type_impl
{
  template<typename T, typename = typename T::type>
  static std::true_type test(int);

  template<typename>
  static std::false_type test(...);
};

template<typename T>
struct has_type : public decltype(has_type_impl::test<T>(0))
{};

template<typename T, typename Res>
struct is_expected_type : public std::is_same<typename T::type, Res>
{};

template<typename P1, typename P2>
struct and_ : public std::conditional<P1::value, P2, std::false_type>::type
{};

template<typename T, typename Res>
struct is_type : public and_<has_type<T>, is_expected_type<T, Res>>
{};

// Types under inspection:

typedef bool (&PF1)();
typedef short (*PF2)(long);

struct S {
  operator PF2() const;
  double operator()(char, int&);
  void calc(long) const;
};

typedef void (S::*PMS)(long) const;
typedef void (S::*PMSnonconst)(long);

typedef int S::* PMI;

struct B {
  int i;
  void f1() const;
  bool f2(int) const volatile;
};

struct D : B {};

typedef void (B::*base_func_void)() const;
typedef bool (B::*base_func_bool_int)(int) const volatile;

struct ident_functor {
  template<typename T>
  T operator()(T&& x);
};

template<typename Ret = void>
struct variable_functor {
  template<typename... T>
  Ret operator()(T&&...);
};

struct ident_functor_noref {
  template<typename T>
  typename std::remove_reference<T>::type operator()(T&& x);
};

enum class ScEn;

enum UnScEn : int;

union U {
  int i;
  double d;
};

union U2 {
  int i;
  bool b;
  void operator()() const;
  int operator()(double) const;
  bool operator()(double);
  U operator()(int, int);
};

struct Ukn;

typedef Ukn (S::*PMSIncomplete)(long) const;
typedef Ukn (S::*PMSIncompletenonconst)(long);
typedef Ukn (*FuncIncomplete)(long);

struct Abstract {
  virtual ~Abstract() = 0;
};

struct Private {
private:
  void operator()();
  int operator()(int);
public:
  bool operator()(std::nullptr_t);
};

union PrivateUnion {
  double d;
private:
  void operator()();
  int operator()(int);
public:
  bool operator()(std::nullptr_t);
};

template<typename T>
struct ImplicitTo {
  operator T();
};

template<typename>
struct never { static const bool value = false; };

template<typename T>
struct BrokenTrait {
  static_assert(never<T>::value, "Error!");
  typedef T type;
};

template<typename T>
struct BadSmartPtr : T {
  T& operator*() const noexcept(typename BrokenTrait<T>::type());
};

template<typename Ret>
using FuncEllipses = Ret(...);

static_assert(is_type<std::result_of<S(int)>, short>::value, "Error!");
static_assert(is_type<std::result_of<S&(unsigned char, int&)>,
	      double>::value, "Error!");
static_assert(is_type<std::result_of<PF1()>, bool>::value, "Error!");
static_assert(is_type<std::result_of<PF1&()>, bool>::value, "Error!");
static_assert(is_type<std::result_of<PMS(std::unique_ptr<S>, int)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<PMS(std::unique_ptr<S>&, unsigned&)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<PMS&(std::unique_ptr<S>, int)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<PMS&(std::unique_ptr<S>&, unsigned&)>,
	      void>::value, "Error!");

static_assert(is_type<std::result_of<ident_functor(int)>,
	      int>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(const int)>,
	      int>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(const int&&)>,
	      int>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(int&&)>,
	      int>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(int&)>,
	      int&>::value, "Error!");

static_assert(is_type<std::result_of<ident_functor(const B)>,
	      B>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(const B&&)>,
	      const B>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(B&&)>, B>::value, "Error!");
static_assert(is_type<std::result_of<ident_functor(B&)>, B&>::value, "Error!");

static_assert(is_type<std::result_of<int B::*(B&)>, int&>::value, "Error!");

// This is expected as of CWG 616 P/R:
static_assert(is_type<std::result_of<int B::*(B)>, int&&>::value, "Error!");

static_assert(is_type<std::result_of<volatile int B::*(const B&&)>,
	      const volatile int&&>::value, "Error!");
static_assert(is_type<std::result_of<const int B::*(volatile B&&)>,
	      const volatile int&&>::value, "Error!");

static_assert(is_type<std::result_of<int B::*(const B&)>,
	      const int&>::value, "Error!");
static_assert(is_type<std::result_of<volatile int B::*(const B&)>,
	      const volatile int&>::value, "Error!");
static_assert(is_type<std::result_of<const int B::*(volatile B&)>,
	      const volatile int&>::value, "Error!");

static_assert(is_type<std::result_of<int B::*(B*)>, int&>::value, "Error!");
static_assert(is_type<std::result_of<int B::*(B*&)>, int&>(), "Error!");
static_assert(is_type<std::result_of<int B::*(const B*)>,
	      const int&>::value, "Error!");
static_assert(is_type<std::result_of<int B::*(const B*&)>,
	      const int&>::value, "Error!");
static_assert(is_type<std::result_of<volatile int B::*(const B*)>,
	      const volatile int&>::value, "Error!");
static_assert(is_type<std::result_of<const int B::*(volatile B*)>,
	      const volatile int&>::value, "Error!");

static_assert(is_type<std::result_of<base_func_void(const B&)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<base_func_void(const B*)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<base_func_void(B&)>,
	      void>::value, "Error!");
static_assert(is_type<std::result_of<base_func_void(B*)>,
	      void>::value, "Error!");

static_assert(!has_type<std::result_of<base_func_void(volatile B&)>>::value,
	      "Error!");
static_assert(!has_type<std::result_of<base_func_void(volatile B*)>>::value,
	      "Error!");

static_assert(is_type<std::result_of<base_func_bool_int(B&, long)>,
	      bool>::value, "Error!");
static_assert(is_type<std::result_of<base_func_bool_int(B*, long)>,
	      bool>::value, "Error!");
static_assert(is_type<std::result_of<base_func_bool_int(volatile B&, long)>,
	      bool>::value, "Error!");
static_assert(is_type<std::result_of<base_func_bool_int(volatile B*, long)>,
	      bool>::value, "Error!");

static_assert(!has_type<std::result_of<int()>>(), "Error!");
static_assert(!has_type<std::result_of<void()>>(), "Error!");
static_assert(!has_type<std::result_of<int(int)>>(), "Error!");
static_assert(!has_type<std::result_of<void(int)>>(), "Error!");
static_assert(!has_type<std::result_of<PF1(int)>>(), "Error!");
static_assert(is_type<std::result_of<PF2(long)>, short>(), "Error!");
static_assert(!has_type<std::result_of<PF2()>>(), "Error!");
static_assert(!has_type<std::result_of<PF2(B)>>(), "Error!");
static_assert(!has_type<std::result_of<PF2(ScEn)>>(), "Error!");
static_assert(is_type<std::result_of<PF2(UnScEn)>, short>(), "Error!");
static_assert(!has_type<std::result_of<PF2(long, int)>>(), "Error!");
static_assert(is_type<std::result_of<PMS(std::unique_ptr<S>, int)>, void>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMS(int)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(int, std::unique_ptr<S>)>>(), "Error!");

// Argument number mismatch:
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>&)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>, int, bool)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>&, int, bool)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMS(S)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(S&)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(S, int, bool)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(S&, int, bool)>>(), "Error!");

// Non-convertible arguments:
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>, S)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMS(std::unique_ptr<S>&, S)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMS(S, S)>>(), "Error!");
static_assert(!has_type<std::result_of<PMS(S&, S)>>(), "Error!");

// cv-violations:
static_assert(!has_type<std::result_of<PMSnonconst(const S&, long)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMSnonconst(const S&&, long)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMSnonconst(const S*, long)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PMSnonconst(const S*&, long)>>(),
	      "Error!");

static_assert(is_type<std::result_of<PMI(S*)>, int&>(), "Error!");
static_assert(is_type<std::result_of<PMI(S&)>, int&>(), "Error!");
static_assert(is_type<std::result_of<PMI(S&&)>, int&&>(), "Error!");
static_assert(is_type<std::result_of<PMI(S)>, int&&>(), "Error!");

static_assert(!has_type<std::result_of<PMI()>>(), "Error!");

static_assert(!has_type<std::result_of<PMI(S*, int)>>(), "Error!");
static_assert(!has_type<std::result_of<PMI(S&, int)>>(), "Error!");
static_assert(!has_type<std::result_of<PMI(S*, int, S, bool)>>(), "Error!");
static_assert(!has_type<std::result_of<PMI(S&, int, S, bool)>>(), "Error!");

static_assert(!has_type<std::result_of<PMI(B*)>>(), "Error!");
static_assert(!has_type<std::result_of<PMI(B&)>>(), "Error!");

static_assert(is_type<std::result_of<int U::*(U)>, int&&>(), "Error!");
static_assert(is_type<std::result_of<int U::*(U&)>, int&>(), "Error!");
static_assert(is_type<std::result_of<int U::*(const U&)>, const int&>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <volatile int U::*(const U&)>, const volatile int&>(), "Error!");
static_assert(is_type<std::result_of
	      <const int U::*(volatile U&)>, const volatile int&>(), "Error!");

static_assert(is_type<std::result_of<int Ukn::*(Ukn*)>, int&>(), "Error!");
static_assert(is_type<std::result_of<int Ukn::*(Ukn&)>, int&>(), "Error!");
static_assert(is_type<std::result_of<int Ukn::*(Ukn&&)>, int&&>(), "Error!");
static_assert(is_type<std::result_of<int Ukn::*(const Ukn*)>, const int&>(),
	      "Error!");
static_assert(is_type<std::result_of<int Ukn::*(const Ukn&)>, const int&>(),
	      "Error!");
static_assert(is_type<std::result_of<int Ukn::*(const Ukn&&)>, const int&&>(),
	      "Error!");

typedef void (Ukn::* PUfnMF)();
typedef void (Ukn::* PUfnConstMF)() const;

static_assert(is_type<std::result_of<PUfnMF(Ukn*)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnMF(Ukn&)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnMF(Ukn&&)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(Ukn*)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(Ukn&)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(Ukn&&)>, void>(), "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(const Ukn*)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(const Ukn&)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<PUfnConstMF(const Ukn&&)>, void>(),
	      "Error!");

static_assert(!has_type<std::result_of<S()>>(), "Error!");
static_assert(!has_type<std::result_of<S(int, S)>>(), "Error!");
static_assert(!has_type<std::result_of<S(S)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <S(double, bool, std::nullptr_t, Ukn&)>>(), "Error!");

static_assert(is_type<std::result_of<U2()>, void>(), "Error!");
static_assert(is_type<std::result_of<const U2&()>, void>(), "Error!");
static_assert(is_type<std::result_of<U2&()>, void>(), "Error!");
static_assert(is_type<std::result_of<U2(double)>, bool>(), "Error!");
static_assert(is_type<std::result_of<const U2&(double)>, int>(), "Error!");
static_assert(is_type<std::result_of<U2&(double)>, bool>(), "Error!");
static_assert(is_type<std::result_of<U2(int)>, bool>(), "Error!");
static_assert(is_type<std::result_of<U2&(int)>, bool>(), "Error!");
static_assert(is_type<std::result_of<const U2&(int)>, int>(), "Error!");
static_assert(is_type<std::result_of<U2(int, int)>, U>(), "Error!");
static_assert(is_type<std::result_of<U2&(int, int)>, U>(), "Error!");

static_assert(!has_type<std::result_of<const U2&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<U2(int, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<U2&(int, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const U2&(int, int, int)>>(), "Error!");

static_assert(is_type<std::result_of<ident_functor(int)>, int>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(const volatile int)>,
	      int>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(int&)>, int&>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(const volatile int&)>,
	      const volatile int&>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(int&&)>, int>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(const volatile int&&)>,
	      int>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(Abstract&)>, Abstract&>(),
	      "Error!");
static_assert(is_type<std::result_of<ident_functor(const volatile Abstract&)>,
	      const volatile Abstract&>(), "Error!");

static_assert(!has_type<std::result_of<ident_functor(int(&&)[1])>>(), "Error!");
static_assert(is_type<std::result_of<ident_functor(Abstract&&)>,Abstract>(), "Error!");
static_assert(!has_type<std::result_of<ident_functor(const int(&&)[1])>>(),
	      "Error!");
static_assert(is_type<std::result_of<ident_functor(const Abstract&&)>,const Abstract>(),
	      "Error!");
static_assert(!has_type<std::result_of<ident_functor_noref(int(&)[1])>>(),
	      "Error!");
static_assert(!has_type<std::result_of<ident_functor_noref
	      (const int(&)[1])>>(), "Error!");
static_assert(is_type<std::result_of<ident_functor_noref(Abstract&)>,Abstract>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <ident_functor_noref(const Abstract&)>,const Abstract>(), "Error!");
static_assert(!has_type<std::result_of<ident_functor_noref(void(&)())>>(),
	      "Error!");
static_assert(!has_type<std::result_of<ident_functor_noref(void(&&)())>>(),
	      "Error!");

static_assert(!has_type<std::result_of<ident_functor()>>(), "Error!");
static_assert(!has_type<std::result_of<ident_functor(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const ident_functor&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<const ident_functor&&(int)>>(),
	      "Error!");

// Border-line case:
static_assert(!has_type<std::result_of<int S::*(Ukn*)>>(), "Error!");
static_assert(!has_type<std::result_of<void (S::*(Ukn*))()>>(), "Error!");

// We want to allow this, it seems to be required by the order described 
// in [func.require] p1:
static_assert(is_type<std::result_of<int S::*(BadSmartPtr<S>&)>, int&>(),
	      "Error!");

static_assert(is_type<std::result_of<Private(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<Private&(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<Private&&(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<Private(ImplicitTo<std::nullptr_t>)>,
	      bool>(), "Error!");
static_assert(is_type<std::result_of<Private&(ImplicitTo<std::nullptr_t>)>,
	      bool>(), "Error!");
static_assert(is_type<std::result_of<Private&&(ImplicitTo<std::nullptr_t>)>,
	      bool>(), "Error!");

static_assert(!has_type<std::result_of<const Private&(std::nullptr_t)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const Private&&(std::nullptr_t)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<Private()>>(), "Error!");
static_assert(!has_type<std::result_of<Private(int)>>(), "Error!");
static_assert(!has_type<std::result_of<Private(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<Private&()>>(), "Error!");
static_assert(!has_type<std::result_of<Private&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<Private&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&()>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<Private&&()>>(), "Error!");
static_assert(!has_type<std::result_of<Private&&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<Private&&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&&()>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&&(int, int)>>(), "Error!");

static_assert(!has_type<std::result_of<Private(ScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<Private(UnScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&(ScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<const Private&(UnScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<Private(ImplicitTo<ScEn>)>>(), "Error!");
static_assert(!has_type<std::result_of<Private(ImplicitTo<UnScEn>)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const Private&(ImplicitTo<ScEn>)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const Private&(ImplicitTo<UnScEn>)>>(),
	      "Error!");

static_assert(is_type<std::result_of<PrivateUnion(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<PrivateUnion&(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<PrivateUnion&&(std::nullptr_t)>, bool>(),
	      "Error!");
static_assert(is_type<std::result_of<PrivateUnion(ImplicitTo<std::nullptr_t>)>,
	      bool>(), "Error!");
static_assert(is_type<std::result_of
	      <PrivateUnion&(ImplicitTo<std::nullptr_t>)>, bool>(), "Error!");
static_assert(is_type<std::result_of
	      <PrivateUnion&&(ImplicitTo<std::nullptr_t>)>, bool>(), "Error!");

static_assert(!has_type<std::result_of<const PrivateUnion&(std::nullptr_t)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const PrivateUnion&&(std::nullptr_t)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion()>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion(int)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&()>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&()>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&(int, int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&&()>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion&&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&&()>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&&(int)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&&(int, int)>>(),
	      "Error!");

static_assert(!has_type<std::result_of<PrivateUnion(ScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<PrivateUnion(UnScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&(ScEn)>>(), "Error!");
static_assert(!has_type<std::result_of<const PrivateUnion&(UnScEn)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PrivateUnion(ImplicitTo<ScEn>)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<PrivateUnion(ImplicitTo<UnScEn>)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const PrivateUnion&(ImplicitTo<ScEn>)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const PrivateUnion&(ImplicitTo<UnScEn>)>>(), "Error!");

static_assert(is_type<std::result_of<void(*(bool))(int)>, void>(), "Error!");
static_assert(is_type<std::result_of<void(*(UnScEn))(int)>, void>(), "Error!");
static_assert(is_type<std::result_of<void(*(ImplicitTo<int>))(int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<void(*(ImplicitTo<int>&))(int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<void(*(ImplicitTo<int>&&))(int)>, void>(),
	      "Error!");

static_assert(!has_type<std::result_of<void(*(ScEn))(int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <void(*(const ImplicitTo<int>&))(int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <void(*(const ImplicitTo<int>&&))(int)>>(), "Error!");

static_assert(is_type<std::result_of<ImplicitTo<void(*)()>()>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<ImplicitTo<void(&)()>()>, void>(),
	      "Error!");

static_assert(!has_type<std::result_of<ImplicitTo<void(*)()>(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<ImplicitTo<void(*)(int)>()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<ImplicitTo<void(&)()>(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<ImplicitTo<void(&)(int)>()>>(),
	      "Error!");

// Conversion operators of types are not considered in call expressions
// (except for conversion to function pointer/reference):
static_assert(!has_type<std::result_of<ImplicitTo<S>(char, int&)>>(), "Error!");
static_assert(!has_type<std::result_of<ImplicitTo<ident_functor>(int)>>(),
	      "Error!");

static_assert(is_type<std::result_of<variable_functor<>()>, void>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<>(int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<>(int, int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<>(int, int, int)>,
	      void>(), "Error!");

static_assert(is_type<std::result_of<variable_functor<>&()>, void>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<>&(int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<>&(int, int)>, void>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<>&(int, int, int)>,
	      void>(), "Error!");

static_assert(!has_type<std::result_of<const variable_functor<>()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<>(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<>(int, int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<>(int, int, int)>>(), "Error!");

static_assert(!has_type<std::result_of<const variable_functor<>&()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<>&(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<>&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<>&(int, int, int)>>(), "Error!");

static_assert(is_type<std::result_of<variable_functor<S>()>, S>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<S>(int)>, S>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<S>(int, int)>, S>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<S>(int, int, int)>, S>(),
	      "Error!");

static_assert(is_type<std::result_of<variable_functor<S>&()>, S>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<S>&(int)>, S>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<S>&(int, int)>, S>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <variable_functor<S>&(int, int, int)>, S>(), "Error!");

static_assert(!has_type<std::result_of
	      <const variable_functor<S>()>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<S>(int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<S>(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<S>(int, int, int)>>(), "Error!");

static_assert(!has_type<std::result_of<const variable_functor<S>&()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<S>&(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<S>&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<S>&(int, int, int)>>(), "Error!");

#if defined(HAS_52748_FIXED)
static_assert(has_type<std::result_of<variable_functor<Ukn>()>>(), "Error!");
static_assert(is_type<std::result_of<variable_functor<Ukn>()>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<Ukn>(int)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<Ukn>(int, int)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <variable_functor<Ukn>(int, int, int)>, Ukn>(), "Error!");

static_assert(is_type<std::result_of<variable_functor<Ukn>&()>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<variable_functor<Ukn>&(int)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <variable_functor<Ukn>&(int, int)>, Ukn>(), "Error!");
static_assert(is_type<std::result_of
	      <variable_functor<Ukn>&(int, int, int)>, Ukn>(), "Error!");

static_assert(is_type<std::result_of<PMSIncomplete(S*, int)>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<PMSIncomplete&(const S&, int)>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<PMSIncomplete&&(S&&, int)>, Ukn>(), "Error!");

static_assert(is_type<std::result_of<FuncIncomplete(int)>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<FuncIncomplete&(int)>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<FuncIncomplete&&(int)>, Ukn>(), "Error!");

static_assert(is_type<std::result_of<FuncEllipses<Ukn>*()>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<FuncEllipses<Ukn>&()>, Ukn>(), "Error!");
static_assert(is_type<std::result_of<FuncEllipses<Ukn>&&()>, Ukn>(), "Error!");

static_assert(is_type<std::result_of<FuncEllipses<Ukn>*(bool)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<Ukn>&(bool)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<Ukn>&&(bool)>, Ukn>(),
	      "Error!");

static_assert(is_type<std::result_of<FuncEllipses<Ukn>*(bool, int, S)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<Ukn>&(bool, int, S)>, Ukn>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <FuncEllipses<Ukn>&&(bool, int, S)>, Ukn>(), "Error!");

static_assert(!has_type<std::result_of<PMSIncompletenonconst(const S*)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*, int, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*&)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*&, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*&, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S*&, int, int, int)>>(), "Error!");

static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&, int, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&&)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&&, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&&, int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <PMSIncompletenonconst(const S&&, int, int, int)>>(), "Error!");
#endif

static_assert(!has_type<std::result_of<const variable_functor<Ukn>()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<Ukn>(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<Ukn>(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<Ukn>(int, int, int)>>(), "Error!");

static_assert(!has_type<std::result_of<const variable_functor<Ukn>&()>>(),
	      "Error!");
static_assert(!has_type<std::result_of<const variable_functor<Ukn>&(int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<Ukn>&(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of
	      <const variable_functor<Ukn>&(int, int, int)>>(), "Error!");

static_assert(!has_type<std::result_of<FuncIncomplete()>>(), "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete(S)>>(), "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete(int, int)>>(), "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete(int, int, int)>>(),
	      "Error!");

static_assert(!has_type<std::result_of<FuncIncomplete&&()>>(), "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete&&(S)>>(), "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete&&(int, int)>>(),
	      "Error!");
static_assert(!has_type<std::result_of<FuncIncomplete&&(int, int, int)>>(),
	      "Error!");

static_assert(is_type<std::result_of<FuncEllipses<int>*()>, int>(), "Error!");
static_assert(is_type<std::result_of<FuncEllipses<int>&()>, int>(), "Error!");
static_assert(is_type<std::result_of<FuncEllipses<int>&&()>, int>(), "Error!");

static_assert(is_type<std::result_of<FuncEllipses<int>*(bool)>, int>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<int>&(bool)>, int>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<int>&&(bool)>, int>(), 
	      "Error!");

static_assert(is_type<std::result_of<FuncEllipses<int>*(bool, int, S)>, int>(),
	      "Error!");
static_assert(is_type<std::result_of<FuncEllipses<int>&(bool, int, S)>, int>(),
	      "Error!");
static_assert(is_type<std::result_of
	      <FuncEllipses<int>&&(bool, int, S)>, int>(), "Error!");