CTAD for alias templates fails with non-template explicit deduction guide

[antangelo]

Example:

template<typename T> struct A {
    A(T);
};

A(int) -> A<char>;

template<typename T>
using B = A<T>;

A a2(100);
B b2(100);

using A2 = A<char>;
using A2 = decltype(a2); // works

using B2 = B<char>;
using B2 = decltype(b2); // fails, deduces A<int>

https://godbolt.org/z/v5W1M4TKq

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (antangelo)

Example: ```cpp template<typename T> struct A { A(T); };

A(int) -> A<char>;

template<typename T>
using B = A<T>;

A a2(100);
B b2(100);

using A2 = A<char>;
using A2 = decltype(a2); // works

using B2 = B<char>;
using B2 = decltype(b2); // fails, deduces A<int>

https://godbolt.org/z/v5W1M4TKq
</details>

[llvmbot]

@llvm/issue-subscribers-c-20

Author: None (antangelo)

Example: ```cpp template<typename T> struct A { A(T); };

A(int) -> A<char>;

template<typename T>
using B = A<T>;

A a2(100);
B b2(100);

using A2 = A<char>;
using A2 = decltype(a2); // works

using B2 = B<char>;
using B2 = decltype(b2); // fails, deduces A<int>

https://godbolt.org/z/v5W1M4TKq
</details>

[zyn0217]

cc @hokein

[hokein]

template<typename T> struct A {
    A(T);
};

A(int) -> A<char>;

template<typename T>
using B = A<T>;

B b2(100);  // deduced A<int>.

The issue here is that we incorrectly deduce B<char>, which should be A<char>. The reason is that we don't have a synthesized deduction guide from the explicitly-written one A(int) -> A<char>.

The explicit deduction guide is treated as a normal FunctionDecl, and we miss this case in https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaTemplate.cpp#L3219-L3221"

[hokein]

My interpretation of the standard is that the synthesized deduction guide is also a non-template function declaration.

However, for alias templates, we have a special is_deducible constraint that the arguments for the alias template are deducible from the deduced type. If the synthesized deduction guide is a non-template function declaration, then we cannot attach this type constraint to it.

Here is an interesting example:

#include <type_traits>

template<typename T> struct A {
    A(T);
};
A(int) -> A<char>;

template<typename T>
requires (!std::is_same<T, char>::value)
using B = A<T>;

B b3(100);

static_assert(std::is_same<decltype(b3), A<char>>::value);

Gcc and msvc behave differently https://godbolt.org/z/8Poh4rf41: gcc respects the (!std::is_same<T, char>::value) constraint, while msvc does not. The gcc behavior seems more intuitive from a user's perspective.

cc @zygoloid