[libc++] Use addressof in assignment operator.

[Mordante]

Summary

Replace &__rhs with _VSTD::addressof(__rhs) to guard against ADL hijacking
of operator& in operator=. Thanks to @CaseyCarter for bringing it to our
attention.

Similar issues with hijacking operator& still exist, they will be
addressed separately.

[jloser]

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.compile.pass.cpp

23 ↗

(On Diff #376261)

Should we explicitly #include <vector>? Do we even need to provide our own container template (I think using the default of std::deque is fine, right?)?

libcxx/test/support/deleted_operator_ampersand.h

29 ↗

(On Diff #376261)

Nit: west const in the function argument list to be consistent with use in the rest of the file.

[CaseyCarter]

libcxx/test/support/deleted_operator_ampersand.h

18 ↗

(On Diff #376261)

typo: "additional"

28 ↗

(On Diff #376261)

#include<functional>?

29 ↗

(On Diff #376261)

#include<cstddef>?

[• Quuxplusone]

libcxx/test/std/containers/associative/map/map.cons/copy_assign.compile.pass.cpp

22 ↗

(On Diff #376261)

The pattern I use for "ADL-proofing tests" is find libcxx/test/ -name robust_against_adl.pass.cpp:

struct Incomplete;
template<class T> struct Holder { T t; };

std::map<int, Holder<Incomplete>*> m;
m = m;

However, the problem here is that std::map actually is not fully ADL-proof, and cannot be made fully ADL-proof, because it relies on comparing allocator<pair<int, Holder<Incomplete>*>> objects with ADL operator!=. So I guess the deleted-specific-function version is the best we can do.

26–28 ↗

(On Diff #376261)

All of these tests can be one line shorter.

std::map<int, deleted_operator_ampersand> x;
x = x;

libcxx/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.compile.pass.cpp

9 ↗

(On Diff #376261)

Throughout: Why is this unsupported in '03?
...oh, because of the =delete? Clang supports =delete in '03, so we can go ahead and test it. This will shorten most of these test files by another 2 lines each.

libcxx/test/support/deleted_operator_ampersand.h

18 ↗

(On Diff #376261)

additional

22–23 ↗

(On Diff #376261)

Let's delete the rest of the evil operators while we're here.

template<class T> friend void operator&(T&&) = delete;
template<class T, class U> friend void operator,(T&&, U&&) = delete;
template<class T, class U> friend void operator&&(T&&, U&&) = delete;
template<class T, class U> friend void operator||(T&&, U&&) = delete;

You can call the class something like class OperatorHijacker or class EvilOperators to keep the lines a bit shorter at the call-sites.

26–31 ↗

(On Diff #376261)

template<>
struct std::hash<WhateverName> {
    size_t operator()(const WhateverName&) const { return 0; }
};

(Never reopen namespace std from user code. Don't put noexcept cruft except where the library needs it.)

[Mordante]

Thanks for the feedback. At the moment it seems the pre-merge checks are disable. So I'll fix it when the CI is in the air again.

[Mordante]

Rebase to trigger CI.

[Mordante]

libcxx/test/std/containers/associative/map/map.cons/copy_assign.compile.pass.cpp

26–28 ↗

(On Diff #376261)

Actually they can't this triggers a self-assignment warning. So I prefer to keep it as is.

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.compile.pass.cpp

23 ↗

(On Diff #376261)

std::vector is the default and yes we should include <vector>, instead I use std::queue which can be used without an additional include.

libcxx/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.compile.pass.cpp

9 ↗

(On Diff #376261)

Indeed because of C++03, thanks for reminding that we can use =delete in Clang in C++03.

[Mordante]

Addresses review comments.
Disable failing debug iterator tests.

[• Quuxplusone]

LGTM % priority_queue.

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.compile.pass.cpp

23 ↗

(On Diff #376261)

std::queue isn't even a container, let alone a random-access container. I agree with @jloser: we don't need to specify a container here. Just std::priority_queue<operator_hijacker> should be fine.

[ldionne]

Thanks for tackling this! LGTM but I do have a few questions.

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.compile.pass.cpp

9 ↗

(On Diff #377290)

Why does this test require the debug mode?

libcxx/test/std/containers/sequences/list/list.cons/assign_copy.compile.pass.cpp

9 ↗

(On Diff #377290)

Can you add a comment explaining why that fails? Applies elsewhere too.

libcxx/test/support/operator_hijacker.h

13

Generally this goes after including the libc++ headers.

[• Quuxplusone]

libcxx/test/std/containers/sequences/list/list.cons/assign_copy.compile.pass.cpp

9 ↗

(On Diff #377290)

Good catches! I didn't notice these new XFAILs; I also don't see any reason they should be needed. I assume the problem has to do with __wrap_iter not being sufficiently ADL-proof? But then we should fix that too.

[Mordante]

Addresses review comments.

[Mordante]

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.compile.pass.cpp

9 ↗

(On Diff #377290)

It doesn't I noticed it before uploading the changes yesterday, but seems I forgot to hit the save button.

libcxx/test/std/containers/sequences/list/list.cons/assign_copy.compile.pass.cpp

9 ↗

(On Diff #377290)

They fail since the debug iterators also use operator&. As stated in the original commit message; there will be follow-up commits. I prefer to keep reviews small. I'll add comments.

[ldionne]

Awesome, thanks for the patch.

Can you rename the new tests to e.g. assign_copy.addressof.compile.pass.cpp so we can tell at a glance that it's testing some sort of addressof-related issue, or operator highjacking?

[Mordante]

Renamed the tests as requested.

libcxx/include/__hash_table

__hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(
     __bucket_list_.get_deleter().__alloc() = __u.__bucket_list_.get_deleter().__alloc();
     __node_alloc() = __u.__node_alloc();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>&
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)
 {
-    if (this != &__u)
+    if (this != _VSTD::addressof(__u))
     {
         __copy_assign_alloc(__u);
         hash_function() = __u.hash_function();
         key_eq() = __u.key_eq();
         max_load_factor() = __u.max_load_factor();
         __assign_multi(__u.begin(), __u.end());
     }
     return *this;

libcxx/include/__tree

if (__cache->__left_ == nullptr)
         return __cache;
     return static_cast<__node_pointer>(_VSTD::__tree_leaf(__cache->__left_));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>&
 __tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t)
 {
-    if (this != &__t)
+    if (this != _VSTD::addressof(__t))
     {
         value_comp() = __t.value_comp();
         __copy_assign_alloc(__t);
         __assign_multi(__t.begin(), __t.end());
     }
     return *this;
 }
 

libcxx/include/deque

 {
     __append(__c.begin(), __c.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>&
 deque<_Tp, _Allocator>::operator=(const deque& __c)
 {
-    if (this != &__c)
+    if (this != _VSTD::addressof(__c))
     {
         __copy_assign_alloc(__c);
         assign(__c.begin(), __c.end());
     }
     return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG

libcxx/include/forward_list

 {
     insert_after(cbefore_begin(), __x.begin(), __x.end());
 }
 
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>&
 forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
 {
-    if (this != &__x)
+    if (this != _VSTD::addressof(__x))
     {
         base::__copy_assign_alloc(__x);
         assign(__x.begin(), __x.end());
     }
     return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG

libcxx/include/list

 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 inline
 list<_Tp, _Alloc>&
 list<_Tp, _Alloc>::operator=(const list& __c)
 {
-    if (this != &__c)
+    if (this != _VSTD::addressof(__c))
     {
         base::__copy_assign_alloc(__c);
         assign(__c.begin(), __c.end());
     }
     return *this;
 }
 
 template <class _Tp, class _Alloc>

libcxx/include/map

map(const map& __m)
         }
 
     _LIBCPP_INLINE_VISIBILITY
     map& operator=(const map& __m)
         {
 #ifndef _LIBCPP_CXX03_LANG
             __tree_ = __m.__tree_;
 #else
-            if (this != &__m) {
+            if (this != _VSTD::addressof(__m)) {
                 __tree_.clear();
                 __tree_.value_comp() = __m.__tree_.value_comp();
                 __tree_.__copy_assign_alloc(__m.__tree_);
                 insert(__m.begin(), __m.end());
             }
 #endif
             return *this;
         }
multimap(const multimap& __m)
         }
 
     _LIBCPP_INLINE_VISIBILITY
     multimap& operator=(const multimap& __m)
         {
 #ifndef _LIBCPP_CXX03_LANG
             __tree_ = __m.__tree_;
 #else
-            if (this != &__m) {
+            if (this != _VSTD::addressof(__m)) {
                 __tree_.clear();
                 __tree_.value_comp() = __m.__tree_.value_comp();
                 __tree_.__copy_assign_alloc(__m.__tree_);
                 insert(__m.begin(), __m.end());
             }
 #endif
             return *this;
         }

libcxx/include/unordered_map

#endif
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(const unordered_map& __u)
     {
 #ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else
-        if (this != &__u) {
+        if (this != _VSTD::addressof(__u)) {
             __table_.clear();
             __table_.hash_function() = __u.__table_.hash_function();
             __table_.key_eq() = __u.__table_.key_eq();
             __table_.max_load_factor() = __u.__table_.max_load_factor();
             __table_.__copy_assign_alloc(__u.__table_);
             insert(__u.begin(), __u.end());
         }
 #endif
#endif
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(const unordered_multimap& __u)
     {
 #ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else
-        if (this != &__u) {
+        if (this != _VSTD::addressof(__u)) {
             __table_.clear();
             __table_.hash_function() = __u.__table_.hash_function();
             __table_.key_eq() = __u.__table_.key_eq();
             __table_.max_load_factor() = __u.__table_.max_load_factor();
             __table_.__copy_assign_alloc(__u.__table_);
             insert(__u.begin(), __u.end());
         }
 #endif

libcxx/include/valarray

valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
     }
     return *this;
 }
 
 template <class _Tp>
 valarray<_Tp>&
 valarray<_Tp>::operator=(const valarray& __v)
 {
-    if (this != &__v)
+    if (this != _VSTD::addressof(__v))
         return __assign_range(__v.__begin_, __v.__end_);
     return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline

libcxx/include/vector

 
 #endif // !_LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(const vector& __x)
 {
-    if (this != &__x)
+    if (this != _VSTD::addressof(__x))
     {
         __base::__copy_assign_alloc(__x);
         assign(__x.__begin_, __x.__end_);
     }
     return *this;
 }
 
 template <class _Tp, class _Allocator>
if (__v.size() > 0)
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>&
 vector<bool, _Allocator>::operator=(const vector& __v)
 {
-    if (this != &__v)
+    if (this != _VSTD::addressof(__v))
     {
         __copy_assign_alloc(__v);
         if (__v.__size_)
         {
             if (__v.__size_ > capacity())
             {
                 __vdeallocate();
                 __vallocate(__v.__size_);

libcxx/test/std/containers/associative/map/map.cons/copy_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// map& operator=(const map& m);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <map>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  {
+    std::map<int, operator_hijacker> mo;
+    std::map<int, operator_hijacker> m;
+    m = mo;
+  }
+  {
+    std::map<operator_hijacker, int> mo;
+    std::map<operator_hijacker, int> m;
+    m = mo;
+  }
+}

libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class multimap
+
+// multimap& operator=(const multimap& m);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <map>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  {
+    std::multimap<int, operator_hijacker> mo;
+    std::multimap<int, operator_hijacker> m;
+    m = mo;
+  }
+  {
+    std::multimap<operator_hijacker, int> mo;
+    std::multimap<operator_hijacker, int> m;
+    m = mo;
+  }
+}

libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class multiset
+
+// multiset& operator=(const multiset& s);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <set>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::multiset<operator_hijacker> so;
+  std::multiset<operator_hijacker> s;
+  s = so;
+}

libcxx/test/std/containers/associative/set/set.cons/copy_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class set
+
+// set& operator=(const set& s);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <set>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::set<operator_hijacker> so;
+  std::set<operator_hijacker> s;
+  s = so;
+}

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// priority_queue& operator=(const priority_queue&) = default;
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <queue>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::priority_queue<operator_hijacker> pqo;
+  std::priority_queue<operator_hijacker> pq;
+  pq = pqo;
+}

libcxx/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// queue& operator=(const queue& q);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <queue>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::queue<operator_hijacker> qo;
+  std::queue<operator_hijacker> q;
+  q = qo;
+}

libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// implicitly generated array assignment operators
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <array>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::array<operator_hijacker, 1> ao;
+  std::array<operator_hijacker, 1> a;
+  a = ao;
+}

libcxx/test/std/containers/sequences/deque/deque.cons/move_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// deque& operator=(deque&& c);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <deque>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::deque<operator_hijacker> dqo;
+  std::deque<operator_hijacker> dq;
+  dq = dqo;
+}

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <forward_list>
+
+// forward_list& operator=(const forward_list& x);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <forward_list>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::forward_list<operator_hijacker> lo;
+  std::forward_list<operator_hijacker> l;
+  l = lo;
+}

libcxx/test/std/containers/sequences/list/list.cons/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Guard the debug iterators against ADL-hijacking.
+// XFAIL: LIBCXX-DEBUG-FIXME
+
+// <list>
+
+// list& operator=(const list& c);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <list>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::list<operator_hijacker> lo;
+  std::list<operator_hijacker> l;
+  l = lo;
+}

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// vector& operator=(const vector& c);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <vector>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::vector<operator_hijacker> vo;
+  std::vector<operator_hijacker> v;
+  v = vo;
+}

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Guard the debug iterators against ADL-hijacking.
+// XFAIL: LIBCXX-DEBUG-FIXME
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// unordered_map& operator=(const unordered_map& u);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <unordered_map>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  {
+    std::unordered_map<int, operator_hijacker> mo;
+    std::unordered_map<int, operator_hijacker> m;
+    m = mo;
+  }
+  {
+    std::unordered_map<operator_hijacker, int> mo;
+    std::unordered_map<operator_hijacker, int> m;
+    m = mo;
+  }
+}

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Guard the debug iterators against ADL-hijacking.
+// XFAIL: LIBCXX-DEBUG-FIXME
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// unordered_multimap& operator=(const unordered_multimap& u);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <unordered_map>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  {
+    std::unordered_multimap<int, operator_hijacker> mo;
+    std::unordered_multimap<int, operator_hijacker> m;
+    m = mo;
+  }
+  {
+    std::unordered_multimap<operator_hijacker, int> mo;
+    std::unordered_multimap<operator_hijacker, int> m;
+    m = mo;
+  }
+}

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Guard the debug iterators against ADL-hijacking.
+// XFAIL: LIBCXX-DEBUG-FIXME
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// unordered_multiset& operator=(const unordered_multiset& u);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <unordered_set>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::unordered_multiset<operator_hijacker> so;
+  std::unordered_multiset<operator_hijacker> s;
+  s = so;
+}

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Guard the debug iterators against ADL-hijacking.
+// XFAIL: LIBCXX-DEBUG-FIXME
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_set
+
+// unordered_set& operator=(const unordered_set& u);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <unordered_set>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::unordered_set<operator_hijacker> so;
+  std::unordered_set<operator_hijacker> s;
+  s = so;
+}

libcxx/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.addressof.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <valarray>
+
+// template<class T> class valarray;
+
+// valarray& operator=(const value_type& x);
+
+// Validate whether the container can be copy-assigned with an ADL-hijacking operator&
+
+#include <valarray>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+  std::valarray<operator_hijacker> vo;
+  std::valarray<operator_hijacker> v;
+  v = vo;
+}

libcxx/test/support/operator_hijacker.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_OPERATOR_HIJACKER_H
+#define SUPPORT_OPERATOR_HIJACKER_H
+
+#include <cstddef>
+#include <functional>
+
+#include "test_macros.h"
+
+/// Helper struct to test ADL-hijacking in containers.
+///
+/// The class has some additional operations to be usable in all containers.
+struct operator_hijacker {
+  bool operator<(const operator_hijacker&) const { return true; }
+  bool operator==(const operator_hijacker&) const { return true; }
+
+  template <typename T>
+  friend void operator&(T&&) = delete;
+  template <class T, class U>
+  friend void operator,(T&&, U&&) = delete;
+  template <class T, class U>
+  friend void operator&&(T&&, U&&) = delete;
+  template <class T, class U>
+  friend void operator||(T&&, U&&) = delete;
+};
+
+template <>
+struct std::hash<operator_hijacker> {
+  size_t operator()(const operator_hijacker&) const { return 0; }
+};
+
+#endif // SUPPORT_OPERATOR_HIJACKER_H