C++ Check if generic object has member function matching signature

first post, so hopefully not violating any etiquette. Feel free to give suggestions for making the question better.

I've seen a few posts similar to this one: Check if a class has a member function of a given signature, but none do quite what I want. Sure it "works with polymorphism" in the sense that it can properly check subclass types for the function that comes from a superclass, but what I'd like to do is check the object itself and not the class. Using some (slightly tweaked) code from that post:

// Somewhere in back-end
#include <type_traits>
template<typename, typename T>
struct HasFunction {
    static_assert(integral_constant<T, false>::value,
        "Second template parameter needs to be of function type."
        );
};

template<typename C, typename Ret, typename... Args>
class HasFunction<C, Ret(Args...)> {

    template<typename T>
    static constexpr auto check(T*) -> typename is_same< 
        decltype(declval<T>().myfunc(declval<Args>()...)), Ret>::type;

    template<typename>
    static constexpr false_type check(...);

    typedef decltype(check<C>(0)) type;
public:
    static constexpr bool value = type::value;
};

struct W {};
struct X : W { int myfunc(double) { return 42; } };
struct Y : X {};

I'd like to have something like the following:

// somewhere else in back-end. Called by client code and doesn't know
// what it's been passed!
template <class T>
void DoSomething(T& obj) {
    if (HasFunction<T, int(double)>::value)
        cout << "Found it!" << endl;
        // Do something with obj.myfunc
    else cout << "Nothin to see here" << endl;
}

int main()
{
    Y y;
    W* w = &y; // same object
    DoSomething(y); // Found it!
    DoSomething(*w); // Nothin to see here?
}

The problem is that the same object being viewed polymorphically causes different results (because the deduced type is what is being checked and not the object). So for example, if I was iterating over a collection of W*'s and calling DoSomething I would want it to no-op on W's but it should do something for X's and Y's. Is this achievable? I'm still digging into templates so I'm still not quite sure what's possible but it seems like it isn't. Is there a different way of doing it altogether?

Also, slightly less related to that specific problem: Is there a way to make HasFunction more like an interface so I could arbitrarily check for different functions? i.e. not have ".myfunc" concrete within it? (seems like it's only possible with macros?) e.g.

template<typename T>
struct HasFoo<T> : HasFunction<T, int foo(void)> {};
int main() {
    Bar b;
    if(HasFoo<b>::value) b.foo();
}

Obviously that's invalid syntax but hopefully it gets the point across.