Possible compiler bug? auto deduction isn't possible when calling a templated method with a pointer retrieved from a templated static member function

Question

UPDATE 2

Why is this marked a duplicate? Where and why do I have to put the “template” and “typename” keywords? doesn't answer this question. The behavior described here isn't mentioned there anywhere (you won't find a single remark about the expected behavior of auto there).

This is not a duplicate, especially since there's a conflicting behavior in different compilers.

---

UPDATE

Much like GCC, clang also fails to compile:

17 : error: expected expression
return p->is<true>();
^

However, on MSVC the code with the auto detection is compiling successfully.

Clearly, there's a compiler bug somewhere.

---

Live example

Consider the following class:

struct A {
    template<bool>
    bool is() const {
        return true;
    }

    template<bool>
    static A* get() {
        static A a;
        return &a;
    }
};

If a template function, such as

template<bool cond>
bool foo() {
    auto p = A::get<cond>();
    return p->is<true>();
}

tries to call A::is<bool>, it fails miserably:

main.cpp: In function 'bool foo()':
main.cpp:17:24: error: expected primary-expression before ')' token
     return p->is<true>();
                        ^
main.cpp: In instantiation of 'bool foo() [with bool cond = true]':
main.cpp:21:22:   required from here
main.cpp:17:17: error: invalid operands of types '<unresolved overloaded function type>' and 'bool' to binary 'operator<'
     return p->is<true>();
                 ^

however, if only we replace auto with the explicit type (A*):

template<bool cond>
bool foo() {
    A* p = A::get<cond>();
    return p->is<true>();
}

it works.

What is the reason for this?

Answer 1

You need to write

return p->template is<true>();

because the compiler does not know initially that is is a template.

---

Some more deep explanation. With

A* p = A::get<cond>();
return p->is<true>();

the compiler knows even when it is parsing the code that p is of type A* and therefore it sees that p->is is a template.

With

auto p = A::get<cond>();
return p->is<true>();

the compiler does not initially know what type p will be. It will know this only after it has instantiated A::get<cond>, and this will happen only when foo is instantiated. So it does not know that p->is is a template. (And it may easily be not a template is you had specialized version of A for, say, true template parameter.)

Further reading: Where and why do I have to put the "template" and "typename" keywords?

---

Quote from the Standard [14.2.4]:

When the name of a member template specialization appears after . or -> in a postfix-expression or after a nested-name-specifier in a qualified-id, and the object expression of the postfix-expression is type-dependent or the nested-name-specifier in the qualified-id refers to a dependent type, but the name is not a member of the current instantiation (14.6.2.1), the member template name must be prefixed by the keyword template. Otherwise the name is assumed to name a non-template.

I think this clearly explains that what is observed is correct behavior. Without auto, the type of p is not type-dependent. With auto, is becomes type-dependent.