Revert "[libc++] ADL-proof <vector> by adding _VSTD:: qualification on calls."

metaflow · metaflow · commit 620adacf87a3 · 2020-11-19T15:36:49.000+01:00
This reverts commit 40267cc. Build fails, e.g. http://lab.llvm.org:8011/#/builders/23/builds/108
diff --git a/libcxx/include/__hash_table b/libcxx/include/__hash_table
@@ -2728,9 +2728,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
     __u.__bucket_list_.reset(__npp);
     }
     _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
-    _VSTD::__swap_allocator(__bucket_list_.get_deleter().__alloc(),
+    __swap_allocator(__bucket_list_.get_deleter().__alloc(),
              __u.__bucket_list_.get_deleter().__alloc());
-    _VSTD::__swap_allocator(__node_alloc(), __u.__node_alloc());
+    __swap_allocator(__node_alloc(), __u.__node_alloc());
     _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
     __p2_.swap(__u.__p2_);
     __p3_.swap(__u.__p3_);
diff --git a/libcxx/include/__split_buffer b/libcxx/include/__split_buffer
@@ -279,7 +279,7 @@ void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
 {
     while (__begin_ != __new_begin)
-        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++));
+        __alloc_traits::destroy(__alloc(), __to_address(__begin_++));
 }
 
 template <class _Tp, class _Allocator>
@@ -296,7 +296,7 @@ void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
 {
     while (__new_last != __end_)
-        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_));
+        __alloc_traits::destroy(__alloc(), __to_address(--__end_));
 }
 
 template <class _Tp, class _Allocator>
@@ -416,7 +416,7 @@ __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
     _VSTD::swap(__begin_, __x.__begin_);
     _VSTD::swap(__end_, __x.__end_);
     _VSTD::swap(__end_cap(), __x.__end_cap());
-    _VSTD::__swap_allocator(__alloc(), __x.__alloc());
+    __swap_allocator(__alloc(), __x.__alloc());
 }
 
 template <class _Tp, class _Allocator>
diff --git a/libcxx/include/__tree b/libcxx/include/__tree
@@ -1819,7 +1819,7 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
     using _VSTD::swap;
     swap(__begin_node_, __t.__begin_node_);
     swap(__pair1_.first(), __t.__pair1_.first());
-    _VSTD::__swap_allocator(__node_alloc(), __t.__node_alloc());
+    __swap_allocator(__node_alloc(), __t.__node_alloc());
     __pair3_.swap(__t.__pair3_);
     if (size() == 0)
         __begin_node() = __end_node();
diff --git a/libcxx/include/deque b/libcxx/include/deque
@@ -1237,7 +1237,7 @@ __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
     __map_.swap(__c.__map_);
     _VSTD::swap(__start_, __c.__start_);
     _VSTD::swap(size(), __c.size());
-    _VSTD::__swap_allocator(__alloc(), __c.__alloc());
+    __swap_allocator(__alloc(), __c.__alloc());
 }
 
 template <class _Tp, class _Allocator>
@@ -2376,7 +2376,7 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
     for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);
+        __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), *__f);
       }
     }
 }
@@ -2393,7 +2393,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)
     for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_));
+        __alloc_traits::construct(__a, std::__to_address(__tx.__pos_));
       }
     }
 }
@@ -2410,7 +2410,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
     for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), __v);
+        __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), __v);
       }
     }
 
@@ -2708,7 +2708,7 @@ void
 deque<_Tp, _Allocator>::pop_front()
 {
     allocator_type& __a = __base::__alloc();
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
+    __alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +
                                                     __base::__start_ / __base::__block_size) +
                                                     __base::__start_ % __base::__block_size));
     --__base::size();
@@ -2723,7 +2723,7 @@ deque<_Tp, _Allocator>::pop_back()
     _LIBCPP_ASSERT(!empty(), "deque::pop_back called for empty deque");
     allocator_type& __a = __base::__alloc();
     size_type __p = __base::size() + __base::__start_ - 1;
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
+    __alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +
                                                     __p / __base::__block_size) +
                                                     __p % __base::__block_size));
     --__base::size();
diff --git a/libcxx/include/forward_list b/libcxx/include/forward_list
@@ -603,7 +603,7 @@ __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
                     __is_nothrow_swappable<__node_allocator>::value)
 #endif
 {
-    _VSTD::__swap_allocator(__alloc(), __x.__alloc(),
+    __swap_allocator(__alloc(), __x.__alloc(),
             integral_constant<bool, __node_traits::propagate_on_container_swap::value>());
     using _VSTD::swap;
     swap(__before_begin()->__next_, __x.__before_begin()->__next_);
diff --git a/libcxx/include/list b/libcxx/include/list
@@ -783,7 +783,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
                    "list::swap: Either propagate_on_container_swap must be true"
                    " or the allocators must compare equal");
     using _VSTD::swap;
-    _VSTD::__swap_allocator(__node_alloc(), __c.__node_alloc());
+    __swap_allocator(__node_alloc(), __c.__node_alloc());
     swap(__sz(), __c.__sz());
     swap(__end_, __c.__end_);
     if (__sz() == 0)
diff --git a/libcxx/include/memory b/libcxx/include/memory
@@ -4898,7 +4898,7 @@ void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
-    _VSTD::__swap_allocator(__a1, __a2,
+    __swap_allocator(__a1, __a2,
       integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
diff --git a/libcxx/include/string b/libcxx/include/string
@@ -3438,7 +3438,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
         __alloc_traits::is_always_equal::value ||
         __alloc() == __str.__alloc(), "swapping non-equal allocators");
     _VSTD::swap(__r_.first(), __str.__r_.first());
-    _VSTD::__swap_allocator(__alloc(), __str.__alloc());
+    __swap_allocator(__alloc(), __str.__alloc());
 }
 
 // find
diff --git a/libcxx/include/vector b/libcxx/include/vector
@@ -951,7 +951,7 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a
 {
 
     __annotate_delete();
-    _VSTD::__construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
+    __construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
@@ -966,8 +966,8 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a
 {
     __annotate_delete();
     pointer __r = __v.__begin_;
-    _VSTD::__construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, __p, __v.__begin_);
-    _VSTD::__construct_forward_with_exception_guarantees(this->__alloc(), __p, this->__end_, __v.__end_);
+    __construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, __p, __v.__begin_);
+    __construct_forward_with_exception_guarantees(this->__alloc(), __p, this->__end_, __v.__end_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
@@ -1074,7 +1074,7 @@ typename enable_if
 vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
 {
     _ConstructTransaction __tx(*this, __n);
-    _VSTD::__construct_range_forward(this->__alloc(), __first, __last, __tx.__pos_);
+    __construct_range_forward(this->__alloc(), __first, __last, __tx.__pos_);
 }
 
 //  Default constructs __n objects starting at __end_
@@ -2054,7 +2054,7 @@ vector<_Tp, _Allocator>::swap(vector& __x)
     _VSTD::swap(this->__begin_, __x.__begin_);
     _VSTD::swap(this->__end_, __x.__end_);
     _VSTD::swap(this->__end_cap(), __x.__end_cap());
-    _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
+    __swap_allocator(this->__alloc(), __x.__alloc(),
         integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->swap(this, &__x);
@@ -3232,7 +3232,7 @@ vector<bool, _Allocator>::swap(vector& __x)
     _VSTD::swap(this->__begin_, __x.__begin_);
     _VSTD::swap(this->__size_, __x.__size_);
     _VSTD::swap(this->__cap(), __x.__cap());
-    _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
+    __swap_allocator(this->__alloc(), __x.__alloc(),
         integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
 }
 
diff --git a/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp b/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ void`
`279`	`279`	`__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)`
`280`	`280`	`{`
`281`	`281`	`while (__begin_ != __new_begin)`
`282`		`- __alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++));`
	`282`	`+ __alloc_traits::destroy(__alloc(), __to_address(__begin_++));`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`template <class _Tp, class _Allocator>`
`@@ -296,7 +296,7 @@ void`
`296`	`296`	`__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT`
`297`	`297`	`{`
`298`	`298`	`while (__new_last != __end_)`
`299`		`- __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_));`
	`299`	`+ __alloc_traits::destroy(__alloc(), __to_address(--__end_));`
`300`	`300`	`}`
`301`	`301`
`302`	`302`	`template <class _Tp, class _Allocator>`
`@@ -416,7 +416,7 @@ __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)`
`416`	`416`	`_VSTD::swap(__begin_, __x.__begin_);`
`417`	`417`	`_VSTD::swap(__end_, __x.__end_);`
`418`	`418`	`_VSTD::swap(__end_cap(), __x.__end_cap());`
`419`		`- _VSTD::__swap_allocator(__alloc(), __x.__alloc());`
	`419`	`+ __swap_allocator(__alloc(), __x.__alloc());`
`420`	`420`	`}`
`421`	`421`
`422`	`422`	`template <class _Tp, class _Allocator>`
Original file line number	Diff line number	Diff line change
`@@ -1237,7 +1237,7 @@ __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)`
`1237`	`1237`	`__map_.swap(__c.__map_);`
`1238`	`1238`	`_VSTD::swap(__start_, __c.__start_);`
`1239`	`1239`	`_VSTD::swap(size(), __c.size());`
`1240`		`- _VSTD::__swap_allocator(__alloc(), __c.__alloc());`
	`1240`	`+ __swap_allocator(__alloc(), __c.__alloc());`
`1241`	`1241`	`}`
`1242`	`1242`
`1243`	`1243`	`template <class _Tp, class _Allocator>`
`@@ -2376,7 +2376,7 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,`
`2376`	`2376`	`for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {`
`2377`	`2377`	`_ConstructTransaction __tx(this, __br);`
`2378`	`2378`	`for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {`
`2379`		`- __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);`
	`2379`	`+ __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), *__f);`
`2380`	`2380`	`}`
`2381`	`2381`	`}`
`2382`	`2382`	`}`
`@@ -2393,7 +2393,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)`
`2393`	`2393`	`for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {`
`2394`	`2394`	`_ConstructTransaction __tx(this, __br);`
`2395`	`2395`	`for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {`
`2396`		`- __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_));`
	`2396`	`+ __alloc_traits::construct(__a, std::__to_address(__tx.__pos_));`
`2397`	`2397`	`}`
`2398`	`2398`	`}`
`2399`	`2399`	`}`
`@@ -2410,7 +2410,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)`
`2410`	`2410`	`for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {`
`2411`	`2411`	`_ConstructTransaction __tx(this, __br);`
`2412`	`2412`	`for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {`
`2413`		`- __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), __v);`
	`2413`	`+ __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), __v);`
`2414`	`2414`	`}`
`2415`	`2415`	`}`
`2416`	`2416`
`@@ -2708,7 +2708,7 @@ void`
`2708`	`2708`	`deque<_Tp, _Allocator>::pop_front()`
`2709`	`2709`	`{`
`2710`	`2710`	`allocator_type& __a = __base::__alloc();`
`2711`		`- __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +`
	`2711`	`+ __alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +`
`2712`	`2712`	`__base::__start_ / __base::__block_size) +`
`2713`	`2713`	`__base::__start_ % __base::__block_size));`
`2714`	`2714`	`--__base::size();`
`@@ -2723,7 +2723,7 @@ deque<_Tp, _Allocator>::pop_back()`
`2723`	`2723`	`_LIBCPP_ASSERT(!empty(), "deque::pop_back called for empty deque");`
`2724`	`2724`	`allocator_type& __a = __base::__alloc();`
`2725`	`2725`	`size_type __p = __base::size() + __base::__start_ - 1;`
`2726`		`- __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +`
	`2726`	`+ __alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +`
`2727`	`2727`	`__p / __base::__block_size) +`
`2728`	`2728`	`__p % __base::__block_size));`
`2729`	`2729`	`--__base::size();`
Original file line number	Diff line number	Diff line change
`@@ -603,7 +603,7 @@ __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)`
`603`	`603`	`__is_nothrow_swappable<__node_allocator>::value)`
`604`	`604`	`#endif`
`605`	`605`	`{`
`606`		`- _VSTD::__swap_allocator(__alloc(), __x.__alloc(),`
	`606`	`+ __swap_allocator(__alloc(), __x.__alloc(),`
`607`	`607`	`integral_constant<bool, __node_traits::propagate_on_container_swap::value>());`
`608`	`608`	`using _VSTD::swap;`
`609`	`609`	`swap(__before_begin()->__next_, __x.__before_begin()->__next_);`
Original file line number	Diff line number	Diff line change
`@@ -4898,7 +4898,7 @@ void __swap_allocator(_Alloc & __a1, _Alloc & __a2)`
`4898`	`4898`	`_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)`
`4899`	`4899`	`#endif`
`4900`	`4900`	`{`
`4901`		`- _VSTD::__swap_allocator(__a1, __a2,`
	`4901`	`+ __swap_allocator(__a1, __a2,`
`4902`	`4902`	`integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());`
`4903`	`4903`	`}`
`4904`	`4904`
Original file line number	Diff line number	Diff line change
`@@ -3438,7 +3438,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)`
`3438`	`3438`	`__alloc_traits::is_always_equal::value \|\|`
`3439`	`3439`	`__alloc() == __str.__alloc(), "swapping non-equal allocators");`
`3440`	`3440`	`_VSTD::swap(__r_.first(), __str.__r_.first());`
`3441`		`- _VSTD::__swap_allocator(__alloc(), __str.__alloc());`
	`3441`	`+ __swap_allocator(__alloc(), __str.__alloc());`
`3442`	`3442`	`}`
`3443`	`3443`
`3444`	`3444`	`// find`