[clang] CTAD deduces alias template that does not satisfy the condition of the alias template

[ImpleLee]

The following code snippet fails static_assert, and the type of i2 is inferred to be (as reported in the diagnostic message) std::array<std::array<int, 3>, 1>, which does not even constitute a legal my_ints.

Godbolt link: https://godbolt.org/z/1Mo9hz4W7 .

#include <array>
#include <type_traits>

template <int N>
using my_ints = std::array<int, N>;

int main() {
    my_ints i = {1, 2, 3};
    my_ints i2 = {i};
    static_assert(std::is_same_v<decltype(i2), decltype(i)>);
    // error: static assertion failed due to requirement 'std::is_same_v<std::array<std::array<int, 3>, 1>, std::array<int, 3>>'
}

[ImpleLee]

Probably related to #84492 , not sure whether this is a duplicate.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Imple Lee (ImpleLee)

The following code snippet fails `static_assert`, and the type of `i2` is inferred to be (as reported in the diagnostic message) `std::array<std::array<int, 3>, 1>`, which does not even constitute a legal `my_ints`.

Godbolt link: https://godbolt.org/z/1Mo9hz4W7 .

#include <array>
#include <type_traits>

template <int N>
using my_ints = std::array<int, N>;

int main() {
    my_ints i = {1, 2, 3};
    my_ints i2 = {i};
    static_assert(std::is_same_v<decltype(i2), decltype(i)>);
    // error: static assertion failed due to requirement 'std::is_same_v<std::array<std::array<int, 3>, 1>, std::array<int, 3>>'
}

[shafik]

CC @hokein @ilya-biryukov

[ImpleLee]

A more simple demo:

#include <array>
#include <type_traits>

template <std::size_t N>
using ints = std::array<int, N>;

ints m = {1., 2.};
static_assert(std::is_same_v<decltype(m), ints<2>>);
// error: static assertion failed due to requirement 'std::is_same_v<std::array<double, 2>, std::array<int, 2>>'

[ImpleLee]

template <typename T>
struct A {
    T data;
};

using A_int = A<int>;
// A_int a = {1.0}; // error: type 'double' cannot be narrowed to 'int' in initializer list [-Wc++11-narrowing]

template <typename=void>
using A2_int = A<int>;
A2_int a2 = {1.0}; // passing

[hokein]

I think it is a symptom of missing the is_deducible constraint for the synthesized deduction guides, #84492.

A simplified case

#include <array>
#include <type_traits>

template <int N>
using my_ints = std::array<int, N>;

int main() {
    std::array<int, 3> i;
    my_ints i2 = {i};
    static_assert(std::is_same_v<decltype(i2), decltype(i)>);
    // error: static assertion failed due to requirement 'std::is_same_v<std::array<std::array<int, 3>, 1>, std::array<int, 3>>'
}

When deducing template arguments for i2 in the function overload resolution, we have two interesting candidates in the overload set:

1. deduction guide template<unsigned int N> array(std::array<int, N>)-> std::array<int, N> (from the array default copy constructor)
2. deduction guide template<class _Tp, class ... _Up> std::array(_Tp, _Up ...)-> array<_Tp, (1 + sizeof... (_Up))> (from the explicit written deduction guide in <array>)

The function argument is i, whose type is std::array<int, std::size_t>. The candidate 1) is not viable because the std::size_t vs unsigned int for the non-type template parameters. And we end up with the candidate 2), which leads to the surprising deduced type array<array<int, 3>>.
(Changing the template parameter from int N to std::size_t N in the alias templates would make it work as excepted)

Ideally, And 2) should not be viable as well (gcc has the correct behavior), because we can not deduce the template argument of the alias my_ints from the deduced type array<array<int, 3>>, but this is_deducible part is missing in the current implementation.

[ImpleLee]

I think it is a symptom of missing the is_deducible constraint for the synthesized deduction guides, #84492.

A simplified case

#include <array>
#include <type_traits>

template <int N>
using my_ints = std::array<int, N>;

int main() {
    std::array<int, 3> i;
    my_ints i2 = {i};
    static_assert(std::is_same_v<decltype(i2), decltype(i)>);
    // error: static assertion failed due to requirement 'std::is_same_v<std::array<std::array<int, 3>, 1>, std::array<int, 3>>'
}

When deducing template arguments for i2 in the function overload resolution, we have two interesting candidates in the overload set:

1. deduction guide template<unsigned int N> array(std::array<int, N>)-> std::array<int, N> (from the array default copy constructor)
2. deduction guide template<class _Tp, class ... _Up> std::array(_Tp, _Up ...)-> array<_Tp, (1 + sizeof... (_Up))> (from the explicit written deduction guide in <array>)

The function argument is i, whose type is std::array<int, std::size_t>. The candidate 1) is not viable because the std::size_t vs unsigned int for the non-type template parameters. And we end up with the candidate 2), which leads to the surprising deduced type array<array<int, 3>>. (Changing the template parameter from int N to std::size_t N in the alias templates would make it work as excepted)

Ideally, And 2) should not be viable as well (gcc has the correct behavior), because we can not deduce the template argument of the alias my_ints from the deduced type array<array<int, 3>>, but this is_deducible part is missing in the current implementation.

I can accept this explanation, and that does solve my question. I am okay if you choose to close this issue as duplicate, or just leave it open until you have implemented the is_deducible constraint.