Compiler error for requires expression with templated base class member function

[rath3t]

The following code fails to compile with clang trunk and clang 16 (See godbolt link).
The templated member function is not found by clang and therefore the static_assert is triggered.

The struct A inherits from T and therefore the base class member function foo exists, thus the static_assert should not trigger.
It works for non-templated base class member functions though.

struct B {
    template <typename S>
    void foo();

    void bar();
};

template <typename T, typename S>
struct A : T {
    auto foo() {
        static_assert(requires { T::template foo<S>(); });  // fails with clang
        static_assert(requires { T::bar(); });  // works with clang and gcc 12.2
    }
};

int main() {
    A<B, double> a;
    a.foo();
}

Godbolt

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Alex_Mueller (rath3t)

The following code fails to compile with clang trunk and clang 16 (See godbolt link). The templated member function is not found by clang and therefore the `static_assert` is triggered.

The struct A inherits from T and therefore the base class member function foo exists, thus the static_assert should not trigger.
It works for non-templated base class member functions though.

struct B {
    template <typename S>
    void foo();

    void bar();
};

template <typename T, typename S>
struct A : T {
    auto foo() {
        static_assert(requires { T::template foo<S>(); });  // fails with clang
        static_assert(requires { T::bar(); });  // works with clang and gcc 12.2
    }
};

int main() {
    A<B, double> a;
    a.foo();
}

Godbolt

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Alex_Mueller (rath3t)

The following code fails to compile with clang trunk and clang 16 (See godbolt link). The templated member function is not found by clang and therefore the `static_assert` is triggered.

The struct A inherits from T and therefore the base class member function foo exists, thus the static_assert should not trigger.
It works for non-templated base class member functions though.

struct B {
    template <typename S>
    void foo();

    void bar();
};

template <typename T, typename S>
struct A : T {
    auto foo() {
        static_assert(requires { T::template foo<S>(); });  // fails with clang
        static_assert(requires { T::bar(); });  // works with clang and gcc 12.2
    }
};

int main() {
    A<B, double> a;
    a.foo();
}

Godbolt

[shafik]

EDG reject both but MSVC accepts both: https://godbolt.org/z/7G8rPY9hz

I don't see why they should be rejected but not totally sure.

CC @erichkeane @cor3ntin

[erichkeane]

I don't have a good idea, but both lookups seem to me like they should work.

[Sirraide]

At a glance, this looks like it’s a duplicate of #83979?

[rath3t]

Ah yes somebody copied my stackoverflow post https://stackoverflow.com/questions/78106241/compiler-divergence-in-delayed-template-instantiation.

[cor3ntin]

@shafik I agree with Erich, both lookup should work.

[shafik]

Ah yes somebody copied my stackoverflow post https://stackoverflow.com/questions/78106241/compiler-divergence-in-delayed-template-instantiation.

In the future it is helpful to link to Stackoverflow bugs, especially if someone on the committee already analyzed the bug then that makes screening a lot faster and we can get to more bugs.

[rath3t]

I will add the stack overflow link in the future thanks! Sorry for the confusion. For my defense though, the answer on stackoverflow came after I posted here.

[shafik]

I will add the stack overflow link in the future thanks! Sorry for the confusion. For my defense though, the answer on stackoverflow came after I posted here.

It is also helpful for discoverability, if someone else has referenced that bug we can tie those bugs together quickly. Same reason to include assertions and backtraces in bug reports.