[libc++] Make sure cals to std::move are always qualified.

[cor3ntin]

Summary

This fixes instances of the newly added
-Wunqualified-std-cast-call.

[cor3ntin]

Change commit message.

[philnik]

Please use std:: instead of _VSTD::.

[cor3ntin]

_VSTD:: -> std::

[philnik]

Where has -Wunqualified-std-cast-call been added?

[aaron.ballman]

Adding some additional reviewers.

[aaron.ballman]

FWIW, the changes look correct to me, but I'm not a regular reviewer for libc++.

[rnk]

In D120509#3343930, @philnik wrote:

Where has -Wunqualified-std-cast-call been added?

It is now part of clang's default warning set, so the latest version of clang warns on these calls.

[rnk]

lgtm

I'm not a libc++ reviewer, but I think it's reasonable to push this to unbreak the build.

[philnik]

If it's enabled by default, this LGTM if CI is happy, but please wait for a second libc++ approver.

[• Quuxplusone]

LGTM, and will land it now.

libcxx/include/barrier

public:
     static constexpr ptrdiff_t max() noexcept {
         return numeric_limits<ptrdiff_t>::max();
     }
 
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
             : __expected(__expected), __base(__construct_barrier_algorithm_base(this->__expected),
                                              &__destroy_barrier_algorithm_base),
-              __expected_adjustment(0), __completion(move(__completion)), __phase(0)
+              __expected_adjustment(0), __completion(std::move(__completion)), __phase(0)
     {
     }
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     arrival_token arrive(ptrdiff_t update)
     {
         auto const __old_phase = __phase.load(memory_order_relaxed);
         for(; update; --update)
             if(__arrive_barrier_algorithm_base(__base.get(), __old_phase)) {
public:
     using arrival_token = bool;
 
     static constexpr ptrdiff_t max() noexcept {
         return numeric_limits<ptrdiff_t>::max();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-        : __expected(__expected), __arrived(__expected), __completion(move(__completion)), __phase(false)
+        : __expected(__expected), __arrived(__expected), __completion(std::move(__completion)), __phase(false)
     {
     }
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     arrival_token arrive(ptrdiff_t update)
     {
         auto const __old_phase = __phase.load(memory_order_relaxed);
         auto const __result = __arrived.fetch_sub(update, memory_order_acq_rel) - update;
         auto const new_expected = __expected.load(memory_order_relaxed);

libcxx/include/valarray

gslice(size_t __start, const valarray<size_t>& __size,
         {__init(__start);}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start, const valarray<size_t>&  __size,
                                  valarray<size_t>&& __stride)
         : __size_(__size),
-          __stride_(move(__stride))
+          __stride_(std::move(__stride))
         {__init(__start);}
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start,       valarray<size_t>&& __size,
                            const valarray<size_t>&  __stride)
-        : __size_(move(__size)),
+        : __size_(std::move(__size)),
           __stride_(__stride)
         {__init(__start);}
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start,       valarray<size_t>&& __size,
                                  valarray<size_t>&& __stride)
-        : __size_(move(__size)),
-          __stride_(move(__stride))
+        : __size_(std::move(__size)),
+          __stride_(std::move(__stride))
         {__init(__start);}
 
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
 
     _LIBCPP_INLINE_VISIBILITY
private:
     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(__gs.__1d_)
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
     gslice_array(gslice&& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(move(__gs.__1d_))
+          __1d_(std::move(__gs.__1d_))
         {}
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
 template <class _Expr>
indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
           __1d_(__ia)
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(move(__ia))
+          __1d_(std::move(__ia))
         {}
 
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
__indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
           __1d_(__ia)
           {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
         : __expr_(__e),
-          __1d_(move(__ia))
+          __1d_(std::move(__ia))
           {}
 
 #endif // _LIBCPP_CXX03_LANG
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     __result_type operator[](size_t __i) const
         {return __expr_[__1d_[__i]];}

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](gslice&& __gs) const
 {
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));
+    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
 }
 
 template <class _Tp>
 inline
 gslice_array<_Tp>
 valarray<_Tp>::operator[](gslice&& __gs)
 {
-    return gslice_array<value_type>(move(__gs), *this);
+    return gslice_array<value_type>(std::move(__gs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<bool>& __vb) const

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<bool>&& __vb) const
 {
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));
+    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
 }
 
 template <class _Tp>
 inline
 mask_array<_Tp>
 valarray<_Tp>::operator[](valarray<bool>&& __vb)
 {
-    return mask_array<value_type>(move(__vb), *this);
+    return mask_array<value_type>(std::move(__vb), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<size_t>& __vs) const

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
 {
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));
+    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
 }
 
 template <class _Tp>
 inline
 indirect_array<_Tp>
 valarray<_Tp>::operator[](valarray<size_t>&& __vs)
 {
-    return indirect_array<value_type>(move(__vs), *this);
+    return indirect_array<value_type>(std::move(__vs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::operator+() const
 {

libcxx/src/filesystem/directory_iterator.cpp

 
 #if defined(_LIBCPP_WIN32API)
 class __dir_stream {
 public:
   __dir_stream() = delete;
   __dir_stream& operator=(const __dir_stream&) = delete;
 
   __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
-                                               __root_(move(__ds.__root_)),
-                                               __entry_(move(__ds.__entry_)) {
+                                               __root_(std::move(__ds.__root_)),
+                                               __entry_(std::move(__ds.__entry_)) {
     __ds.__stream_ = INVALID_HANDLE_VALUE;
   }
 
   __dir_stream(const path& root, directory_options opts, error_code& ec)
       : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
     if (root.native().empty()) {
       ec = make_error_code(errc::no_such_file_or_directory);
       return;

 };
 #else
 class __dir_stream {
 public:
   __dir_stream() = delete;
   __dir_stream& operator=(const __dir_stream&) = delete;
 
   __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_),
-                                                __root_(move(other.__root_)),
-                                                __entry_(move(other.__entry_)) {
+                                                __root_(std::move(other.__root_)),
+                                                __entry_(std::move(other.__entry_)) {
     other.__stream_ = nullptr;
   }
 
   __dir_stream(const path& root, directory_options opts, error_code& ec)
       : __stream_(nullptr), __root_(root) {
     if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
       ec = detail::capture_errno();
       const bool allow_eacces =

 }
 
 directory_iterator& directory_iterator::__increment(error_code* ec) {
   _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
   ErrorHandler<void> err("directory_iterator::operator++()", ec);
 
   error_code m_ec;
   if (!__imp_->advance(m_ec)) {
-    path root = move(__imp_->__root_);
+    path root = std::move(__imp_->__root_);
     __imp_.reset();
     if (m_ec)
       err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
   }
   return *this;
 }
 
 directory_entry const& directory_iterator::__dereference() const {
recursive_directory_iterator::recursive_directory_iterator(
   __dir_stream new_s(p, opt, m_ec);
   if (m_ec)
     err.report(m_ec);
   if (m_ec || !new_s.good())
     return;
 
   __imp_ = make_shared<__shared_imp>();
   __imp_->__options_ = opt;
-  __imp_->__stack_.push(move(new_s));
+  __imp_->__stack_.push(std::move(new_s));
 }
 
 void recursive_directory_iterator::__pop(error_code* ec) {
   _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
   if (ec)
     ec->clear();
   __imp_->__stack_.pop();
   if (__imp_->__stack_.size() == 0)
while (stack.size() > 0) {
     if (stack.top().advance(m_ec))
       return;
     if (m_ec)
       break;
     stack.pop();
   }
 
   if (m_ec) {
-    path root = move(stack.top().__root_);
+    path root = std::move(stack.top().__root_);
     __imp_.reset();
     err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
   } else {
     __imp_.reset();
   }
 }
 
 bool recursive_directory_iterator::__try_recursion(error_code* ec) {
if (m_ec && status_known(st))
       m_ec.clear();
     if (m_ec || !is_directory(st))
       skip_rec = true;
   }
 
   if (!skip_rec) {
     __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
     if (new_it.good()) {
-      __imp_->__stack_.push(move(new_it));
+      __imp_->__stack_.push(std::move(new_it));
       return true;
     }
   }
   if (m_ec) {
     const bool allow_eacess =
         bool(__imp_->__options_ & directory_options::skip_permission_denied);
     if (m_ec.value() == EACCES && allow_eacess) {
       if (ec)
         ec->clear();
     } else {
-      path at_ent = move(curr_it.__entry_.__p_);
+      path at_ent = std::move(curr_it.__entry_.__p_);
       __imp_.reset();
       err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
                  at_ent.c_str());
     }
   }
   return false;
 }
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM