[concepts] Clang ignores using-declaration of template member of base class

[marehr]

Bugzilla Link	51544
Version	12.0
OS	Linux
CC	@zygoloid

Extended Description

Hi clang-team,

I'm not sure if this is a defect or standard behaviour, but the following code compiles with gcc, but not with clang:

#include <concepts>

#ifndef MODE
#define MODE 0
#endif

struct base {
#if MODE == 0
  void foo(float target){};
#elif MODE == 1
  template <typename target_t>
  void foo(target_t target){};
#elif MODE == 2
  template <std::floating_point target_t>
  void foo(target_t target){};
#endif
};
struct bar : public base {
  using base::foo;

  template <std::integral target_t>
  void foo(target_t target){};
};
int main() {
  bar f{};
  f.foo(float{});
}

https://godbolt.org/z/4j5Ec688n

MODE	0	1	2
gcc	✓	✓	✓
clang	✓	✗	✗
msvc	✓	✗	✗

I'm unsure if constructs like this are even allowed.

Thank you!

[Quuxplusone]

Yes, this is supposed to work, so this is a Clang bug. Reduced: https://godbolt.org/z/5xhsbq1Y9

template<class> concept False = false;

struct Base {
    static void foo(auto);
};
struct Derived : public Base {
    using Base::foo;
    template<False T> static void foo(T x);
};
int main() {
    Derived::foo(42);
}

There should be two Derived::foos visible here: the one using'ed from Base, and the one declared in Derived itself. But Clang for some reason isn't seeing the using'ed one. Making the using'ed one a non-template (e.g. changing auto to int) makes Clang happy.
Weirdly, Clang is also happy if you use requires!

struct Base {
    static void foo(auto);
};
struct Derived : public Base {
    using Base::foo;
    template<class T> static void foo(T x) requires False<T>; // OK
};
int main() {
    Derived::foo(42);
}

[usx95]

Spent quite sometime on this and looks like the issue occurs while computing whether the two are overloads or not:

Adding requires clause to template head or constraining the template parameter type is ineffective because, even though it creates a non-equivalent template head temp.over.link#6 and hence eligible for overload resolution, Derived::foo still hides any previous using decl.
Clang diverges from gcc here and can be seen more clearly in this example:

struct base {
  template <int N, int M>
  int foo() { return 1; };
};

struct bar : public base {
  using base::foo;
  template <int N> 
  int foo() { return 2; };
};

int main() {
  bar f;
  f.foo<10, 10>(); // clang errors while GCC does not.
}

https://godbolt.org/z/v5hnh6czq. We see that bar::foo hides base::foo because it only differs in the head.

Adding a trailing requires to the definition was a nice find. In this case, clang considers them overloads because of mismatching requires clause.. So both of them make it to the overload resolution (where constrained Derived::foo is rejected then).
Related patch: e9cccd8

[Will try to find what the standard says about when should we hide using decl]. But IMO this part definitely needs a refresh after concepts. At this point this looks inconsistent.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[usx95]

Sent out fix: https://reviews.llvm.org/D136440