[libcxx] [test] bind's function call operator isn't guaranteed to SFINAE.

[STL_MSFT]

Summary

bind's function call operator isn't guaranteed to SFINAE.

There's nothing in the Standard that specifies this, and MSVC's implementation doesn't do it (we explode in a tuple bounds check). For portability, anything expecting the function call operator to vanish should be marked as libcxx-specific, unless and until a Library Issue is voted in saying otherwise.

[EricWF]

r276576.

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp

 // Check that the call operators have the proper return type and that they
 // only SFINAE away when too few arguments are provided. Otherwise they should
 // be well formed and should ignore any additional arguments.
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 int dummy = 42;
 
 int return_value(int) { return dummy; }
 int& return_lvalue(int) { return dummy; }
 const int& return_const_lvalue(int) { return dummy; }
 int&& return_rvalue(int) { return std::move(dummy); }
 const int&& return_const_rvalue(int) { return std::move(dummy); }
 
if ((std::is_reference<Expect>::value)) {
         assert(&exp == &dummy);
         assert(&exp2 == &dummy);
         assert(&exp_r == &dummy);
         assert(&exp_r2 == &dummy);
     }
     // Check that the call operator SFINAE's away when too few arguments
     // are provided but is well-formed otherwise.
     {
-        static_assert(!CheckCall<Bind>(), "");
+        LIBCPP_STATIC_ASSERT(!CheckCall<Bind>(), "");
         static_assert(CheckCall<Bind, int>(), "");
         static_assert(CheckCall<Bind, int, int>(), "");
-        static_assert(!CheckCall<BindR>(), "");
+        LIBCPP_STATIC_ASSERT(!CheckCall<BindR>(), "");
         static_assert(CheckCall<BindR, int>(), "");
         static_assert(CheckCall<BindR, int, int>(), "");
     }
 }
 
 
 // Test but with an explicit return type which differs from the real one.
 template <class Expect, class Fn>
 void do_test_r(Fn* func) {
     using namespace std::placeholders;
     auto ret = std::bind<Expect>(func, _1);
     using Bind = decltype(ret);
     using Ret = decltype(ret(42));
     using Ret2 = decltype(ret(42, 43)); // Test that the extra argument is discarded.
     static_assert(std::is_same<Ret, Expect>::value, "");
     static_assert(std::is_same<Ret2, Expect>::value, "");
     Expect exp = ret(100); // the input value is ignored
     Expect exp2 = ret(101, 102);
     assert(exp == 42);
     assert(exp2 == 42);
     // Check that the call operator SFINAE's away when too few arguments
     // are provided but is well-formed otherwise.
     {
-        static_assert(!CheckCall<Bind>(), "");
+        LIBCPP_STATIC_ASSERT(!CheckCall<Bind>(), "");
         static_assert(CheckCall<Bind, int>(), "");
         static_assert(CheckCall<Bind, int, int>(), "");
     }
 }
 
 int main()
 {
     do_test<int>(return_value);