Fix clang builds due to being unable to use shortcut-syntax for overloaded. You must specify the whole signature (how droll).

sol/function.hpp

@@ -27,6 +27,7 @@
 #include "stack.hpp"
 #include "function_types.hpp"
 #include "userdata_traits.hpp"
+#include "resolve.hpp"
 #include <cstdint>
 #include <functional>
 #include <memory>

sol/resolve.hpp

@@ -0,0 +1,95 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013 Danny Y., Rapptz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SOL_RESOLVE_HPP
+#define SOL_RESOLVE_HPP
+
+#include "traits.hpp"
+#include "tuple.hpp"
+
+namespace sol {
+namespace detail {
+template<class R, class... Args, class F, class = typename std::result_of<Unqualified<F>( Args... )>::type>
+auto resolve_i( types<R( Args... )>, F&& )->R( Unqualified<F>::* )( Args... ) {
+    typedef R( Sig )( Args... );
+    typedef Unqualified<F> Fu;
+    return static_cast<Sig Fu::*>( &Fu::operator() );
+}
+
+template<class F>
+auto resolve_f( std::true_type, F&& f ) -> decltype( resolve_i( types<function_signature_t<decltype( &Unqualified<F>::operator() )>>( ), std::forward<F>( f ) ) ) {
+    typedef Unqualified<F> Fu;
+    return resolve_i( types<function_signature_t<decltype( &Fu::operator() )>>( ), std::forward<F>( f ) );
+}
+
+template<class F>
+void resolve_f( std::false_type, F&& f ) {
+    static_assert( has_deducible_signature<F>::value, "Cannot use no-template-parameter call with an overloaded functor: specify the signature" );
+}
+
+template<class F>
+auto resolve_i( types<>, F&& f ) -> decltype( resolve_f( has_deducible_signature<Unqualified<F>> {}, std::forward<F>( f ) ) ) {
+    return resolve_f( has_deducible_signature<Unqualified<F>> {}, std::forward<F>( f ) );
+}
+
+template<class... Args, class F, class R = typename std::result_of<F&( Args... )>::type>
+auto resolve_i( types<Args...>, F&& f ) -> decltype( resolve_i( types<R( Args... )>( ), std::forward<F>( f ) ) ) {
+    return resolve_i( types<R( Args... )>( ), std::forward<F>( f ) );
+}
+
+template<class Sig, class C>
+Sig C::* resolve_v( std::false_type, Sig C::* mem_func_ptr ) {
+    return mem_func_ptr;
+}
+
+template<class Sig, class C>
+Sig C::* resolve_v( std::true_type, Sig C::* mem_variable_ptr ) {
+    return mem_variable_ptr;
+}
+} // detail
+
+template<class... Args, class R>
+auto resolve( R fun_ptr( Args... ) ) -> R( *)( Args... ) {
+    return fun_ptr;
+}
+
+template<class Sig>
+Sig* resolve( Sig* fun_ptr ) {
+    return fun_ptr;
+}
+
+template<class... Args, class R, class C>
+auto resolve( R( C::*mem_ptr )( Args... ) ) -> R( C::* )( Args... ) {
+    return mem_ptr;
+}
+
+template<class Sig, class C>
+Sig C::* resolve( Sig C::* mem_ptr ) {
+    return detail::resolve_v( std::is_member_object_pointer<Sig C::*>( ), mem_ptr );
+}
+
+template<class... Sig, class F>
+auto resolve( F&& f ) ->  decltype( detail::resolve_i( types<Sig...>( ), std::forward<F>( f ) ) ) {
+    return detail::resolve_i( types<Sig...>( ), std::forward<F>( f ) );
+}
+} // sol
+
+#endif // SOL_RESOLVE_HPP

sol/traits.hpp

@@ -145,6 +145,24 @@ struct is_function_impl<T, true> {
 };
 } // detail
 
+namespace detail {
+template<class F>
+struct check_deducible_signature {
+    template<class G>
+    static auto test( int ) -> decltype( &G::operator(), void( ) );
+    template<class>
+    static auto test( ... ) -> struct nat;
+
+    using type = std::is_void < decltype( test<F>( 0 ) ) > ;
+};
+} // detail
+
+template<class F>
+struct has_deducible_signature : detail::check_deducible_signature<F>::type { };
+
+template <typename T>
+using has_deducible_signature_t = typename has_deducible_signature<T>::type;
+
 template<typename T>
 struct Function : Bool<detail::is_function_impl<T>::value> {};
 

tests.cpp

@@ -410,17 +410,26 @@ TEST_CASE("functions/overloaded", "Check if overloaded function resolution templ
     lua.set_function("non_overloaded", non_overloaded);
     REQUIRE_NOTHROW(lua.script("x = non_overloaded(1)\nprint(x)"));
 
+    /*
+    // Cannot reasonably support: clang++ refuses to try enough
+    // deductions to make this work
     lua.set_function<int>("overloaded", overloaded);
     REQUIRE_NOTHROW(lua.script("print(overloaded(1))"));
 
     lua.set_function<int, int>("overloaded", overloaded);
     REQUIRE_NOTHROW(lua.script("print(overloaded(1, 2))"));
 
+    lua.set_function<int, int, int>("overloaded", overloaded);
+    REQUIRE_NOTHROW(lua.script("print(overloaded(1, 2, 3))"));
+    */
+    lua.set_function<int(int)>("overloaded", overloaded);
+    REQUIRE_NOTHROW(lua.script("print(overloaded(1))"));
+
     lua.set_function<int(int, int)>("overloaded", overloaded);
     REQUIRE_NOTHROW(lua.script("print(overloaded(1, 2))"));
 
-    lua.set_function<int, int, int>("overloaded", overloaded);
+    lua.set_function<int(int, int, int)>("overloaded", overloaded);
-    REQUIRE_NOTHROW(lua.script("print(overloaded(1, 2, 3))"));
+    REQUIRE_NOTHROW(lua.script("print(overloaded(1, 2))"));
 }
 
 TEST_CASE("functions/return_order_and_multi_get", "Check if return order is in the same reading order specified in Lua") {