[libc++] Use addressof in list.

[Mordante]

Summary

This addresses the usage of operator& in <list>.

(Note there are still more headers with the same issue.)

[• Quuxplusone]

Minor test nits, but a fair number of nits.

libcxx/include/list

185

Consider adding #include <__memory/addressof.h> here.

libcxx/test/std/containers/sequences/list/list.modifiers/emplace.addressof.compile.pass.cpp

24

Here l.front() is UB. Is it safe to just do l.emplace(l.begin()) instead, or does that not trigger the codepath you're interested in?
...ah, I see this is a compile-only test... but still, let's avoid the avoidable UB, here and throughout.
Alternatively, change this to

void test(std::list<operator_hijacker>& l) {
  l.emplace(l.begin(), l.front());
}

Ditto on at least four test files below.

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.addressof.compile.pass.cpp

13

The comment on line 14 is mis-copy-and-pasted: this is not copy-assignment.
Ditto in many of these test files.

libcxx/test/std/containers/sequences/list/list.ops/merge_comp.addressof.compile.pass.cpp

12

Stray & here. But this comment line seems unnecessary.

[Mordante]

libcxx/include/list

185

We already include <memory> at line 190 which should provide addressof.

libcxx/test/std/containers/sequences/list/list.modifiers/emplace.addressof.compile.pass.cpp

24

I like your suggestion to make the list an argument of the function!

libcxx/test/std/containers/sequences/list/list.ops/merge_comp.addressof.compile.pass.cpp

12

It's copied from another test. I'll remove the &.

[Mordante]

Addresses review comments.

[• Quuxplusone]

Seems reasonable to me.

libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.addressof.compile.pass.cpp

23–24

Nit: You don't do it = for insert; I don't think you need to do it for erase.

libcxx/include/list

template <class T, class Allocator, class Predicate>
     erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
#if _LIBCPP_DEBUG_LEVEL == 2
     ~__list_const_iterator()
     {
         __get_db()->__erase_i(this);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __list_const_iterator& operator=(const __list_const_iterator& __p)
     {
-        if (this != &__p)
+        if (this != _VSTD::addressof(__p))
         {
-            __get_db()->__iterator_copy(this, &__p);
+            __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
             __ptr_ = __p.__ptr_;
         }
         return *this;
     }
 
 #endif // _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const
#endif
     if (__c.__sz() == 0)
         __c.__end_.__next_ = __c.__end_.__prev_ = __c.__end_as_link();
     else
         __c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_ = __c.__end_as_link();
 
 #if _LIBCPP_DEBUG_LEVEL == 2
     __libcpp_db* __db = __get_db();
     __c_node* __cn1 = __db->__find_c_and_lock(this);
-    __c_node* __cn2 = __db->__find_c(&__c);
+    __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
     _VSTD::swap(__cn1->beg_, __cn2->beg_);
     _VSTD::swap(__cn1->end_, __cn2->end_);
     _VSTD::swap(__cn1->cap_, __cn2->cap_);
     for (__i_node** __p = __cn1->end_; __p != __cn1->beg_;)
     {
         --__p;
         const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
         if (__i->__ptr_ == __c.__end_as_link())
list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT
     return allocator_type(base::__node_alloc());
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::insert(iterator, x) called with an iterator not"
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
     ++base::__sz();
 #if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(__hold.release()->__as_link(), this);
 #else
     return iterator(__hold.release()->__as_link());
 #endif
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::insert(iterator, n, x) called with an iterator not"
         " referring to this list");
     iterator __r(__p.__ptr_, this);
 #else
     iterator __r(__p.__ptr_);
 #endif
     if (__n > 0)
     {

 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::emplace(iterator, args...) called with an iterator not"
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold.get()->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
     ++base::__sz();
     __hold.release();
 #if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::insert(iterator, x) called with an iterator not"
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_pointer __nl = __hold->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
#endif
     __node_alloc_traits::deallocate(__na, __np, 1);
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::erase(const_iterator __p)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::erase(iterator) called with an iterator not"
         " referring to this list");
 #endif
     _LIBCPP_ASSERT(__p != end(),
         "list::erase(iterator) called with a non-dereferenceable iterator");
     __node_allocator& __na = base::__node_alloc();
     __link_pointer __n = __p.__ptr_;
     __link_pointer __r = __n->__next_;
#endif // _LIBCPP_NO_EXCEPTIONS
         base::__sz() += __ds;
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
 {
-    _LIBCPP_ASSERT(this != &__c,
+    _LIBCPP_ASSERT(this != _VSTD::addressof(__c),
                    "list::splice(iterator, list) called with this == &list");
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::splice(iterator, list) called with an iterator not"
         " referring to this list");
 #endif
     if (!__c.empty())
     {
         __link_pointer __f = __c.__end_.__next_;
         __link_pointer __l = __c.__end_.__prev_;
         base::__unlink_nodes(__f, __l);
         __link_nodes(__p.__ptr_, __f, __l);
         base::__sz() += __c.__sz();
         __c.__sz() = 0;
 #if _LIBCPP_DEBUG_LEVEL == 2
-        if (&__c != this) {
+        if (_VSTD::addressof(__c) != this) {
             __libcpp_db* __db = __get_db();
             __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(&__c);
+            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
             for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
             {
                 --__ip;
                 iterator* __i = static_cast<iterator*>((*__ip)->__i_);
                 if (__i->__ptr_ != __c.__end_as_link())
                 {
                     __cn1->__add(*__ip);
                     (*__ip)->__c_ = __cn1;
                     if (--__cn2->end_ != __ip)
                         _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*));
                 }
             }
             __db->unlock();
         }
 #endif
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::splice(iterator, list, iterator) called with the first iterator"
         " not referring to this list");
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__i) == &__c,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__i)) == _VSTD::addressof(__c),
         "list::splice(iterator, list, iterator) called with the second iterator"
         " not referring to the list argument");
-    _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(&__i),
+    _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(_VSTD::addressof(__i)),
         "list::splice(iterator, list, iterator) called with the second iterator"
         " not dereferenceable");
 #endif
     if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_)
     {
         __link_pointer __f = __i.__ptr_;
         base::__unlink_nodes(__f, __f);
         __link_nodes(__p.__ptr_, __f, __f);
         --__c.__sz();
         ++base::__sz();
 #if _LIBCPP_DEBUG_LEVEL == 2
-        if (&__c != this) {
+        if (_VSTD::addressof(__c) != this) {
             __libcpp_db* __db = __get_db();
             __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(&__c);
+            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
             for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
             {
                 --__ip;
                 iterator* __j = static_cast<iterator*>((*__ip)->__i_);
                 if (__j->__ptr_ == __f)
                 {
                     __cn1->__add(*__ip);
                     (*__ip)->__c_ = __cn1;
                     if (--__cn2->end_ != __ip)
                         _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*));
                 }
             }
             __db->unlock();
         }
 #endif
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
         "list::splice(iterator, list, iterator, iterator) called with first iterator not"
         " referring to this list");
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == &__c,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__f)) == _VSTD::addressof(__c),
         "list::splice(iterator, list, iterator, iterator) called with second iterator not"
         " referring to the list argument");
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == &__c,
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__l)) == _VSTD::addressof(__c),
         "list::splice(iterator, list, iterator, iterator) called with third iterator not"
         " referring to the list argument");
-    if (this == &__c)
+    if (this == _VSTD::addressof(__c))
     {
         for (const_iterator __i = __f; __i != __l; ++__i)
             _LIBCPP_ASSERT(__i != __p,
                            "list::splice(iterator, list, iterator, iterator)"
                            " called with the first iterator within the range"
                            " of the second and third iterators");
     }
 #endif
     if (__f != __l)
     {
         __link_pointer __first = __f.__ptr_;
         --__l;
         __link_pointer __last = __l.__ptr_;
-        if (this != &__c)
+        if (this != _VSTD::addressof(__c))
         {
             size_type __s = _VSTD::distance(__f, __l) + 1;
             __c.__sz() -= __s;
             base::__sz() += __s;
         }
         base::__unlink_nodes(__first, __last);
         __link_nodes(__p.__ptr_, __first, __last);
 #if _LIBCPP_DEBUG_LEVEL == 2
-        if (&__c != this) {
+        if (_VSTD::addressof(__c) != this) {
             __libcpp_db* __db = __get_db();
             __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(&__c);
+            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
             for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
             {
                 --__ip;
                 iterator* __j = static_cast<iterator*>((*__ip)->__i_);
                 for (__link_pointer __k = __f.__ptr_;
                                               __k != __l.__ptr_; __k = __k->__next_)
                 {
                     if (__j->__ptr_ == __k)
if (this != _VSTD::addressof(__c))
             }
             else
                 ++__f1;
         }
         splice(__e1, __c);
 #if _LIBCPP_DEBUG_LEVEL == 2
         __libcpp_db* __db = __get_db();
         __c_node* __cn1 = __db->__find_c_and_lock(this);
-        __c_node* __cn2 = __db->__find_c(&__c);
+        __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
         for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
         {
             --__p;
             iterator* __i = static_cast<iterator*>((*__p)->__i_);
             if (__i->__ptr_ != __c.__end_as_link())
             {
                 __cn1->__add(*__p);
                 (*__p)->__c_ = __cn1;

libcxx/test/std/containers/sequences/list/list.cons/assign_move.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <list>
+
+// list& operator=(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 = std::move(lo);
+}

libcxx/test/std/containers/sequences/list/list.modifiers/emplace.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <list>
+
+// template <class... Args> void emplace(const_iterator p, Args&&... args);
+
+// 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> l;
+  l.emplace(l.begin(), l.front());
+}

libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator erase(const_iterator position);
+
+// 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> l;
+  std::list<operator_hijacker>::const_iterator it;
+  it = l.erase(l.begin());
+}

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <list>
+
+// iterator insert(const_iterator position, value_type&& x);
+
+// 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> l;
+  l.insert(l.begin(), operator_hijacker{});
+}

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator insert(const_iterator position, size_type n, const value_type& x);
+
+// 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> l;
+  l.insert(l.begin(), l.size(), l.front());
+}

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator insert(const_iterator position, const value_type& x);
+
+// 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> l;
+  l.insert(l.begin(), l.front());
+}

libcxx/test/std/containers/sequences/list/list.ops/merge_comp.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// template <class Compare> void merge(list& x, Compare comp);
+// If (&addressof(x) == this) does nothing; otherwise ...
+
+// 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> l;
+  l.merge(l, std::less<operator_hijacker>());
+}

libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void splice(const_iterator position, list<T,Allocator>& x, iterator i);
+
+// 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> l;
+  l.splice(l.end(), l, l.begin());
+}

libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void splice(const_iterator position, list& x, iterator first, iterator last);
+
+// 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> l;
+  l.splice(l.end(), l, l.begin(), l.end());
+}

libcxx/test/std/containers/sequences/list/list.special/swap.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
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// template <class T, class Alloc>
+//   void swap(list<T,Alloc>& x, list<T,Alloc>& y);
+
+// 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;
+  swap(l, lo);
+}