why std::is_copy_assignable_v alway true when apply on std::unordered_map

I'm trying to use std::is_copy_assignable_v to detect whether a class has Class& operator=(const Class&):

#include <iostream>
#include <memory>
#include <unordered_map>
#include <map>

int main() {
    // All of them are true, Why???
    std::cout << std::is_copy_assignable_v<std::unordered_map<int, int>> << std::endl;
    std::cout << std::is_copy_assignable_v<std::unordered_map<int, std::unique_ptr<int>>> << std::endl;
    std::cout << std::is_copy_assignable_v<std::unordered_map<std::unique_ptr<int>, std::unique_ptr<int>>> << std::endl;
    std::cout << std::is_copy_assignable_v<std::unordered_map<std::unique_ptr<int>, int>> << std::endl;

    return 0;
}

std::unique_ptr will delete it's copy assignment function and so will std::unordered_map, isn't it?

And the compile say it has copy assignment, but when I try:

std::unordered_map<std::unique_ptr<int>, int> a;
std::unordered_map<std::unique_ptr<int>, int> b;
a = b;

It can't compile.

This doesn't seem to be a compiler problem either(try it on godbolt).

Here is a simplified demonstration.

template <typename A>
struct testme {
    void operator=(const testme&) {
        static_assert(sizeof(A) == 11111);
    }
};

int main()
{
    std::cout << std::is_copy_assignable_v<testme<int>>;
}

The problem here is that is_copy_assignable_v (or any SFINAE-based check really) does not do deep template instantiation. The standardese for this is "immediate context". In our case is_copy_assignable_v in effect checks that the expression

declval<testme<int>&>() = declval<const testme<int>&>

is valid (the assignment operator is declared and not deleted). But it doesn't check testme<int>::operator= body because it is not in the immediate context of the parameter being substituted.

Without changing this fundamental property of the language, the only way to make sure that things like std::unordered_map<std::unique_ptr<int>, int> a; are not classified as copy assignable is to require that every single template explicitly SFINAEs away its assignment operator. In case of std::unordered_map, the copy assignment operator declaration, instead of looking like this

auto operator=(const unordered_map& other) -> unordered_map&

should be something like this

auto operator=(const unordered_map& other) -> 
        enable_if_t<is_copy_constructible_v<_Value_type>,
                    unordered_map&>

Add here the copy constructor, move assignment, and move constructor, and multiply by the number of templates in the library, and it's a whole lot of work for the library implementors. And it still guarantees nothing. The users should do the same with their templates, otherwise unordered_map<int, testme<int>> would be still classified as copy assignable.

As an example let me show you the nonsense that C++ permits

#include <memory>

template<typename T>
class foo
{
    T a;
    public:
    foo() = default;
    foo(foo const& other) : a(other.a)
    {
        
    }
};

template<typename T>
class goo
{
    T a;
    public:
    goo() = default;
    goo(goo const& other) = default;
};

static_assert(std::is_copy_constructible_v<foo<std::unique_ptr<int> > >); // tests if foo(foo const&) is declared - it is
static_assert(!std::is_copy_constructible_v<goo<std::unique_ptr<int> > >); // tests if goo(goo const&) declaration does not exist - it doesn't 

int main()
{
    foo<std::unique_ptr<int> > b; // compiles despite faulty foo(foo const&) as it is never instantiated
    // foo<std::unique_ptr<int> > c(b); // will fail to compile

    return 0;
}

Basically, compiler views std::unordered_map<int, std::unique_ptr<int>> to be copy assignable but assignment fails to compile because implementation has bugs. Yet as long as it is never instantiated there won't be any compilation error reports.

I think you can file a defect in STL.