[Clang] Invalid diagnostic when checking trailing requires of inherited ctor

[alimpfard]

Bisected to aeee4eb, present in main (7090c10).

Reduced test case:

template <typename T, typename U> inline constexpr bool IsSame = false;
template <typename T> inline constexpr bool IsSame<T, T> = true;

struct Empty {};
struct X {};

template <typename T, typename E = X> struct Test {
  Test()
    requires(IsSame<T, Empty>);
};

template <typename XType>
struct Test<void, XType> : public Test<Empty, XType> {
  using Test<Empty, XType>::Test;
};

void foo() {
    Test<void>();
}

Accepted before aeee4eb, error since:

test.cpp:18:5: error: invalid reference to function 'Test': constraints not satisfied
    Test<void>();
    ^
test.cpp:9:14: note: because 'IsSame<X, Empty>' evaluated to false
    requires(IsSame<T, Empty>);
             ^

[llvmbot]

@llvm/issue-subscribers-c-20

[shafik]

CC @zygoloid looks like your NFC change had unintended consequences

[zygoloid]

Interesting; despite what the comment said, the code that was removed was not always performing an identity substitution. So that change also fixes a rejects-valid bug for this case:

template <typename T, typename U> inline constexpr bool IsSame = false;
template <typename T> inline constexpr bool IsSame<T, T> = true;

struct A {};

template <typename T> struct B {
  B() requires IsSame<T*, A>;
  B();
};

template <typename U = int, typename V = A>
struct C : public B<V&> {
  using B<V&>::B;
};

void foo() {
  C();
}

I think the original code in this issue was only working by chance, and the new state is closer to correct. We'll need to make template argument collection for the constraints on an inherited constructor step to the class in which the constructor was declared (the base class, as described by the using declaration's qualifier) instead of the class in which the constructor was found (the derived class). For multi-level inheritance, we'll need to substitute into the middle class's nested-name-specifier to find the proper way to name the base-most class in terms of the derived-most class's template parameters.

[zygoloid]

This is weird. It looks like the bug only affects the cases where we would build a CXXTemporaryObjectExpr:

template <typename T, typename U = void*> struct B {
  B() requires __is_same(T, int);
};

template <typename U> struct B<void, U> : B<int, U> {
  using B<int, U>::B;
};
  
void g(B<void>);

void f() {
  // All accepted.
  B<void> b1;
  B<void> b2{};
  B<void> b3 = {};
  new B<void>{};
  new B<void>();
  g({});

  // All rejected.
  B<void>{};
  B<void>();
}