[libc++][NFC] Address clang-tidy warnings in include/

[philnik]

Summary

This PR disables llvm-header-guard and llvm-include-order for libc++ and addresses the warnings that are currently activated.

[• Quuxplusone]

libcxx/include/__algorithm/copy.h

72

FWIW, I find the left-hand code easier to read and easier to safely-modify than the right-hand code. (This applies, for me, everywhere clang-tidy is introducing early-returns and/or removing braces from if-bodies.)
However, if we really want to do this, I won't loudly object.

libcxx/include/__functional/bind.h

73

These comment-only diffs are clearly a good idea and you should just land them immediately in their own commit, in order to shorten this PR. (Maybe wait for @ldionne or @Mordante or @cjdb to +1 this comment, for the sake of protocol.)

libcxx/include/__functional/hash.h

225–230

The original binary-tree-of-ifs was clearly done intentionally, and this is tight-loop code; but if I had to bet one way or the other, I guess I'd bet this refactor was fine. If done, it should be landed in its own commit, for ease of bisecting.

libcxx/include/__memory/auto_ptr.h

41–42

This specific suppression seems OK, but then you do this like a million more times, for other assignment operators, for various reasons such as "oh no it uses enable_if" :)
I think you should just add -misc-unconventional-assign-operator to the .clang-tidy file. That instantly removes like half of the diffs in this PR.

libcxx/include/regex

2664–2672

What was clang-tidy complaining about here, specifically?
Don't these diffs change a tail-call into a non-tail-call, and isn't that generally a bad thing? (Of course in these cases the optimizer will DTRT anyway, but I bet it's a pessimization for -O0 mode.)

[ldionne]

In general, I like the comment fixes and some of the reformatting, however I don't see the point of most of the control flow changes, and in many cases it felt to me like the status quo was better.

libcxx/include/__algorithm/minmax_element.h

50

Honestly, I find the left hand side easier to read -- I don't understand why clang-tidy is suggesting this change. Anyone?

libcxx/include/__bit_reference

69

This change LGTM.

libcxx/include/__functional/bind.h

73

+1

libcxx/include/__memory/auto_ptr.h

41–42

Agreed -- IMO clang-tidy and such tools are well suited for normal code bases, however this is the Standard Library, and sometimes we have to do things that are outside of what should be considered "normal". For instance, we *have* to leave these unconventional assignments there because they are required by the Standard -- in a normal code base I'd even go further and remove everything that mentions auto_ptr, but obviously that doesn't apply to us.

[philnik]

• factored out namespace comments into D114947
• disabled misc-unconventional-assign-operator
• refactored minmax_element

libcxx/include/__algorithm/minmax_element.h

50

I think it is 'move the code to the left as much as possible'. I definitely agree with the sentiment, and personally don't really find it harder to read. Do you want to keep else in general or only in this specific case?

libcxx/include/regex

2664–2672

clang-tidy complains that operator=() does not return *this (it's another case of misc-unconventional-assign-operator). It does of course return *this through assign, but I think explicitly returning *this makes it look less weird. I thought it would compile to the same assembly, but that probably isn't the case in -O0. I'll revert the changes when I disable misc-unconventional-assign-operator. And what does DTRT stand for?

[• Quuxplusone]

libcxx/include/__algorithm/move.h

68–72

Nit: please make sure to strip any trailing whitespace from the changed lines.

libcxx/include/regex

2664–2672

DTRT = Do The Right Thing (with a somewhat ironic connotation that the "right thing" is "obvious" and therefore can be handwaved).

(For the record, experimental evidence agrees that the right-hand side's assembly is the same at -O1 and slightly worse at -O0: https://godbolt.org/z/x7rjTjz4a )

[• Quuxplusone]

libcxx/.clang-tidy

2

I don't know if we're close to consensus one way or the other on the if-else/early-return refactorings, but IMHO this one-line diff in the .clang-tidy file is now uncontroversial and can be landed ASAP if you want. (Someone +1 that?)

[ldionne]

I'm happy with the few places that only re-format existing code in obvious ways, but anything where we change else if into if or things like that, I don't think it improves the code. I also think removing { and } from single-statement ifs is not really a plus in most cases that I've seen in this patch.

libcxx/.clang-tidy

2

Yeah, +1 on adding this part. All the rest of the patch, I don't think much of it is an improvement over what we had before.

libcxx/.clang-tidy

 InheritParentConfig: true
-Checks: '-readability-identifier-naming'
+Checks: '-readability-identifier-naming,-llvm-header-guard,-llvm-include-order'

libcxx/include/__algorithm/copy.h

__copy(_Tp* __first, _Tp* __last, _Up* __result)
     return __result + __n;
 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    if (__libcpp_is_constant_evaluated()) {
+    if (__libcpp_is_constant_evaluated())
         return _VSTD::__copy_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__copy(_VSTD::__unwrap_iter(__first),
-                          _VSTD::__unwrap_iter(__last),
-                          _VSTD::__unwrap_iter(__result)));
-    }
-}
+
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_H

libcxx/include/__algorithm/copy_backward.h

 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
 copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    if (__libcpp_is_constant_evaluated()) {
+    if (__libcpp_is_constant_evaluated())
         return _VSTD::__copy_backward_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
-                                   _VSTD::__unwrap_iter(__last),
-                                   _VSTD::__unwrap_iter(__result)));
-    }
-}
+
+    return _VSTD::__rewrap_iter(__result, 
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_BACKWARD_H

libcxx/include/__algorithm/is_permutation.h

 __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                  _ForwardIterator2 __last2, _BinaryPredicate __pred, forward_iterator_tag, forward_iterator_tag) {
   //  shorten sequences as much as possible by lopping of any equal prefix
   for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
     if (!__pred(*__first1, *__first2))
       break;
   if (__first1 == __last1)
     return __first2 == __last2;
-  else if (__first2 == __last2)
+  if (__first2 == __last2)
     return false;
 
   typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
   _D1 __l1 = _VSTD::distance(__first1, __last1);
 
   typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2;
   _D2 __l2 = _VSTD::distance(__first2, __last2);
   if (__l1 != __l2)

libcxx/include/__algorithm/minmax_element.h

if (__first != __last)
               if (++__first == __last)
               {
                   if (__comp(*__i, *__result.first))
                       __result.first = __i;
                   else if (!__comp(*__i, *__result.second))
                       __result.second = __i;
                   break;
               }
-              else
-              {
-                  if (__comp(*__first, *__i))
-                  {
-                      if (__comp(*__first, *__result.first))
-                          __result.first = __first;
-                      if (!__comp(*__i, *__result.second))
-                          __result.second = __i;
-                  }
-                  else
-                  {
-                      if (__comp(*__i, *__result.first))
-                          __result.first = __i;
-                      if (!__comp(*__first, *__result.second))
-                          __result.second = __first;
-                  }
-              }
-          }
-      }
-  }
   return __result;
 }
 
 template <class _ForwardIterator>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last)
 {
     return _VSTD::minmax_element(__first, __last,
               __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_MINMAX_ELEMENT_H

libcxx/include/__algorithm/move.h

__move(_Tp* __first, _Tp* __last, _Up* __result)
     return __result + __n;
 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    if (__libcpp_is_constant_evaluated()) {
+    if (__libcpp_is_constant_evaluated())
         return _VSTD::__move_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__move(_VSTD::__unwrap_iter(__first),
-                          _VSTD::__unwrap_iter(__last),
-                          _VSTD::__unwrap_iter(__result)));
-    }
-}
+        
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_MOVE_H

libcxx/include/__algorithm/move_backward.h

 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    if (__libcpp_is_constant_evaluated()) {
+    if (__libcpp_is_constant_evaluated()) 
         return _VSTD::__move_backward_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__move_backward(_VSTD::__unwrap_iter(__first),
-                                   _VSTD::__unwrap_iter(__last),
-                                   _VSTD::__unwrap_iter(__result)));
-    }
+    
+    
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_MOVE_BACKWARD_H

libcxx/include/__algorithm/nth_element.h

while (true)
                 ++__n_swaps;
             } else {
                 // *__first == *__m, *__m <= all other elements
                 // Partition instead into [__first, __i) == *__first and *__first < [__i, __last)
                 ++__i;  // __first + 1
                 __j = __last;
                 if (!__comp(*__first, *--__j)) {  // we need a guard if *__first == *(__last-1)
                     while (true) {
-                        if (__i == __j) {
+                        if (__i == __j)
                             return;  // [__first, __last) all equivalent elements
-                        } else if (__comp(*__first, *__i)) {
+                        if (__comp(*__first, *__i)) {
                             swap(*__i, *__j);
                             ++__n_swaps;
                             ++__i;
                             break;
                         }
                         ++__i;
                     }
                 }

libcxx/include/__algorithm/sort.h

__restart:
             bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
             if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+difference_type(1), __last, __comp))
             {
                 if (__fs)
                     return;
                 __last = __i;
                 continue;
             }
-            else
-            {
-                if (__fs)
-                {
-                    __first = ++__i;
-                    continue;
-                }
-            }
-        }
+            
         // sort smaller range with recursive call and larger with tail recursion elimination
         if (__i - __first < __last - __i)
         {
           _VSTD::__introsort<_Compare>(__first, __i, __comp, __depth);
           __first = ++__i;
         }
         else
         {

libcxx/include/__bit_reference

__bit_reference& operator=(bool __x) _NOEXCEPT
         if (__x)
             *__seg_ |= __mask_;
         else
             *__seg_ &= ~__mask_;
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
-        {return operator=(static_cast<bool>(__x));}
+    __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT {
+      operator=(static_cast<bool>(__x));
+      return *this;
+    }
 
     _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
     _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
         {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY
     __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
while (__d1 != 0 && __d2 != 0)
         {
             if (__d1 <= __bit_array<_Cp>::capacity())
             {
                 __bit_array<_Cp> __b(__d1);
                 _VSTD::copy(__first, __middle, __b.begin());
                 _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
                 break;
             }
-            else
-            {
-                __bit_iterator<_Cp, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
-                __first = __middle;
-                __middle = __mp;
-                __d2 -= __d1;
-            }
-        }
         else
         {
             if (__d2 <= __bit_array<_Cp>::capacity())
             {
                 __bit_array<_Cp> __b(__d2);
                 _VSTD::copy(__middle, __last, __b.begin());
                 _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
                 break;
             }
-            else
-            {
-                __bit_iterator<_Cp, false> __mp = __first + __d2;
-                _VSTD::swap_ranges(__first, __mp, __middle);
-                __first = __mp;
-                __d1 -= __d2;
-            }
-        }
-    }
     return __r;
 }
 
 // equal
 
 template <class _Cp, bool _IC1, bool _IC2>
 bool
 __equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,

libcxx/include/__functional/bind.h

 /* inline */ constexpr __ph<5>   _5{};
 /* inline */ constexpr __ph<6>   _6{};
 /* inline */ constexpr __ph<7>   _7{};
 /* inline */ constexpr __ph<8>   _8{};
 /* inline */ constexpr __ph<9>   _9{};
 /* inline */ constexpr __ph<10> _10{};
 #endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
 
-}  // placeholders
+} // namespace placeholders
 
 template<int _Np>
 struct __is_placeholder<placeholders::__ph<_Np> >
     : public integral_constant<int, _Np> {};
 
 
 #ifndef _LIBCPP_CXX03_LANG
 

libcxx/include/__functional/function.h

#ifndef _LIBCPP_NO_RTTI
 
     template <typename _Tp>
     _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
     {
         if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
             return nullptr;
         if (__policy_->__clone) // Out of line storage.
             return reinterpret_cast<const _Tp*>(__buf_.__large);
-        else
-            return reinterpret_cast<const _Tp*>(&__buf_.__small);
     }
 #endif // _LIBCPP_NO_RTTI
 };
 
 #if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC)
 
 extern "C" void *_Block_copy(const void *);
 extern "C" void _Block_release(const void *);
#ifndef _LIBCPP_NO_RTTI
     virtual const std::type_info& target_type() const _NOEXCEPT {
         return typeid(__func::__block_type);
     }
 #endif // _LIBCPP_NO_RTTI
 };
 
 #endif // _LIBCPP_HAS_EXTENSION_BLOCKS && !_LIBCPP_HAS_OBJC_ARC
 
-}  // __function
+} // namespace __function
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
 #if _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
 #endif
 {

libcxx/include/__functional/hash.h

 };
 
 // cityhash64
 template <class _Size>
 _Size
 __murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len)
 {
   const char* __s = static_cast<const char*>(__key);
-  if (__len <= 32) {
-    if (__len <= 16) {
-      return __hash_len_0_to_16(__s, __len);
-    } else {
-      return __hash_len_17_to_32(__s, __len);
-    }
-  } else if (__len <= 64) {
+
+  if (__len <= 16)
+  if (__len <= 32)
+  if (__len <= 64)
     return __hash_len_33_to_64(__s, __len);
-  }
 
   // For strings over 64 bytes we hash the end first, and then as we
   // loop we keep 56 bytes of state: v, w, x, y, and z.
   _Size __x = __loadword<_Size>(__s + __len - 40);
   _Size __y = __loadword<_Size>(__s + __len - 16) +
               __loadword<_Size>(__s + __len - 56);
   _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
                           __loadword<_Size>(__s + __len - 24));

libcxx/include/__memory/allocator.h

public:
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT { }
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     _Tp* allocate(size_t __n) {
         if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_bad_array_new_length();
-        if (__libcpp_is_constant_evaluated()) {
+        if (__libcpp_is_constant_evaluated())
             return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
-        } else {
-            return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
-        }
-    }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
         if (__libcpp_is_constant_evaluated()) {
             ::operator delete(__p);
         } else {
             _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
         }
public:
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT { }
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const _Tp* allocate(size_t __n) {
         if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_bad_array_new_length();
-        if (__libcpp_is_constant_evaluated()) {
+        if (__libcpp_is_constant_evaluated())
             return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
-        } else {
-            return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
-        }
-    }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void deallocate(const _Tp* __p, size_t __n) {
         if (__libcpp_is_constant_evaluated()) {
             ::operator delete(const_cast<_Tp*>(__p));
         } else {
             _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
         }

libcxx/include/__memory/auto_ptr.h

private:
     _Tp* __ptr_;
 public:
     typedef _Tp element_type;
 
     _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
     template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT
         : __ptr_(__p.release()) {}
+
+    // Reason: non-const auto_ptr& is required by the C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT
         {reset(__p.release()); return *this;}
     template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT
         {reset(__p.release()); return *this;}
     _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT
         {reset(__p.__ptr_); return *this;}
     _LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;}
 

libcxx/include/__memory/shared_ptr.h

public:
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
                    typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
                          _NOEXCEPT;
     ~weak_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp>
+  // Reason: clang-tidy does not recognize enable_if
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
         typename enable_if
         <
             __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
+  // Reason: clang-tidy does not recognize enable_if
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
         typename enable_if
         <
             __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
     template<class _Yp>
+  // Reason: clang-tidy does not recognize enable_if
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
         typename enable_if
         <
             __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 

 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
+// Reason: clang-tidy does not recognize enable_if
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
+// Reason: clang-tidy does not recognize enable_if
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
+// Reason: clang-tidy does not recognize enable_if
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type

libcxx/include/__memory/unique_ptr.h

#endif
   unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
+  // Reason: clang-tidy does not recognize enable_if
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
   _LIBCPP_INLINE_VISIBILITY
       typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                              is_same<_Dp, default_delete<_Tp> >::value,
                          unique_ptr&>::type
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }

libcxx/include/__nullptr

 
 _LIBCPP_END_NAMESPACE_STD
 
 #else  // _LIBCPP_HAS_NO_NULLPTR
 
 namespace std
 {
     typedef decltype(nullptr) nullptr_t;
-}
+} // namespace std
 
 #endif // _LIBCPP_HAS_NO_NULLPTR
 
 #endif // _LIBCPP_NULLPTR

libcxx/include/__threading_support

inline __libcpp_timespec_t __convert_to_timespec(const chrono::nanoseconds& __ns)
   {
     __ts.tv_sec = __ts_sec_max;
     __ts.tv_nsec = 999999999; // (10^9 - 1)
   }
 
   return __ts;
 }
 
-}
+} // namespace __thread_detail
 
 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 
 int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
 {
   pthread_mutexattr_t attr;
   int __ec = pthread_mutexattr_init(&attr);
   if (__ec)

 class _LIBCPP_TYPE_VIS thread;
 class _LIBCPP_TYPE_VIS __thread_id;
 
 namespace this_thread
 {
 
 _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
 
-}  // this_thread
+} // namespace this_thread
 
 template<> struct hash<__thread_id>;
 
 class _LIBCPP_TEMPLATE_VIS __thread_id
 {
     // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
     // NULL is the no-thread value on Darwin.  Someone needs to check
     // on other platforms.  We assume 0 works everywhere for now.

 
 inline _LIBCPP_INLINE_VISIBILITY
 __thread_id
 get_id() _NOEXCEPT
 {
     return __libcpp_thread_get_current_id();
 }
 
-}  // this_thread
+} // namespace this_thread
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_THREADING_SUPPORT

libcxx/include/__tree

if (__hint == end() || !value_comp()(*__hint, __v))  // check before
         if (__prior == begin() || !value_comp()(__v, *--__prior))
         {
             // *prev(__hint) <= __v <= *__hint
             if (__hint.__ptr_->__left_ == nullptr)
             {
                 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
                 return __parent->__left_;
             }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
-                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
-            }
-        }
         // __v < *prev(__hint)
         return __find_leaf_high(__parent, __v);
     }
     // else __v > *__hint
     return __find_leaf_low(__parent, __v);
 }
 
 // Find place to insert if __v doesn't exist
if (__hint == end() || value_comp()(__v, *__hint))  // check before
         if (__prior == begin() || value_comp()(*--__prior, __v))
         {
             // *prev(__hint) < __v < *__hint
             if (__hint.__ptr_->__left_ == nullptr)
             {
                 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
                 return __parent->__left_;
             }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
-                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
-            }
-        }
         // __v <= *prev(__hint)
         return __find_equal(__parent, __v);
     }
-    else if (value_comp()(*__hint, __v))  // check after
+    if (value_comp()(*__hint, __v))  // check after
     {
         // *__hint < __v
         const_iterator __next = _VSTD::next(__hint);
         if (__next == end() || value_comp()(__v, *__next))
         {
             // *__hint < __v < *_VSTD::next(__hint)
             if (__hint.__get_np()->__right_ == nullptr)
             {
                 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
                 return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
             }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__next.__ptr_);
-                return __parent->__left_;
-            }
-        }
         // *next(__hint) <= __v
         return __find_equal(__parent, __v);
     }
     // else __v == *__hint
     __parent = static_cast<__parent_pointer>(__hint.__ptr_);
     __dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
     return __dummy;
 }

libcxx/include/__utility/rel_ops.h

 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const _Tp& __x, const _Tp& __y)
 {
     return !(__x < __y);
 }
 
-}  // rel_ops
+} // namespace rel_ops
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_REL_OPS_H

libcxx/include/atomic

 #else
     _LIBCPP_INLINE_VISIBILITY
     atomic() _NOEXCEPT _LIBCPP_DEFAULT
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator=(_Tp __d) volatile _NOEXCEPT
         {__base::store(__d); return __d;}
+
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator=(_Tp __d) _NOEXCEPT
         {__base::store(__d); return __d;}
 
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
 };
 
 // atomic<T*>
 
 template <class _Tp>
 struct atomic<_Tp*>
     : public __atomic_base<_Tp*>
 {
     typedef __atomic_base<_Tp*> __base;
     typedef _Tp* value_type;
     typedef ptrdiff_t difference_type;
 
     _LIBCPP_INLINE_VISIBILITY
     atomic() _NOEXCEPT _LIBCPP_DEFAULT
 
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator=(_Tp* __d) volatile _NOEXCEPT
         {__base::store(__d); return __d;}
+
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator=(_Tp* __d) _NOEXCEPT
         {__base::store(__d); return __d;}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
         // __atomic_fetch_add accepts function pointers, guard against them.
         static_assert(!is_function<typename remove_pointer<_Tp>::type>::value, "Pointer to function isn't allowed");

libcxx/include/bit

 int __countr_zero(_Tp __t) _NOEXCEPT
 {
     static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countr_zero requires an unsigned integer type");
     if (__t == 0)
         return numeric_limits<_Tp>::digits;
 
     if      (sizeof(_Tp) <= sizeof(unsigned int))
         return __libcpp_ctz(static_cast<unsigned int>(__t));
-    else if (sizeof(_Tp) <= sizeof(unsigned long))
+    if (sizeof(_Tp) <= sizeof(unsigned long))
         return __libcpp_ctz(static_cast<unsigned long>(__t));
-    else if (sizeof(_Tp) <= sizeof(unsigned long long))
+    if (sizeof(_Tp) <= sizeof(unsigned long long))
         return __libcpp_ctz(static_cast<unsigned long long>(__t));
-    else
-    {
-        int __ret = 0;
-        const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
-        while (static_cast<unsigned long long>(__t) == 0uLL)
-        {
-            __ret += __ulldigits;
-            __t >>= __ulldigits;
-        }
-        return __ret + __libcpp_ctz(static_cast<unsigned long long>(__t));
-    }
-}
+
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 int __countl_zero(_Tp __t) _NOEXCEPT
 {
     static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type");
     if (__t == 0)
         return numeric_limits<_Tp>::digits;
 
     if      (sizeof(_Tp) <= sizeof(unsigned int))
         return __libcpp_clz(static_cast<unsigned int>(__t))
               - (numeric_limits<unsigned int>::digits - numeric_limits<_Tp>::digits);
-    else if (sizeof(_Tp) <= sizeof(unsigned long))
+    if (sizeof(_Tp) <= sizeof(unsigned long))
         return __libcpp_clz(static_cast<unsigned long>(__t))
               - (numeric_limits<unsigned long>::digits - numeric_limits<_Tp>::digits);
-    else if (sizeof(_Tp) <= sizeof(unsigned long long))
+    if (sizeof(_Tp) <= sizeof(unsigned long long))
         return __libcpp_clz(static_cast<unsigned long long>(__t))
               - (numeric_limits<unsigned long long>::digits - numeric_limits<_Tp>::digits);
-    else
-    {
-        int __ret = 0;
-        int __iter = 0;
-        const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
-        while (true) {
-            __t = __rotr(__t, __ulldigits);
-            if ((__iter = __countl_zero(static_cast<unsigned long long>(__t))) != __ulldigits)
-                break;
-            __ret += __iter;
-            }
-        return __ret + __iter;
-    }
-}
+    
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 int __countl_one(_Tp __t) _NOEXCEPT
 {
     static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_one requires an unsigned integer type");
     return __t != numeric_limits<_Tp>::max()
         ? __countl_zero(static_cast<_Tp>(~__t))

 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 int __popcount(_Tp __t) _NOEXCEPT
 {
     static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__popcount requires an unsigned integer type");
     if      (sizeof(_Tp) <= sizeof(unsigned int))
         return __libcpp_popcount(static_cast<unsigned int>(__t));
-    else if (sizeof(_Tp) <= sizeof(unsigned long))
+    if (sizeof(_Tp) <= sizeof(unsigned long))
         return __libcpp_popcount(static_cast<unsigned long>(__t));
-    else if (sizeof(_Tp) <= sizeof(unsigned long long))
+    if (sizeof(_Tp) <= sizeof(unsigned long long))
         return __libcpp_popcount(static_cast<unsigned long long>(__t));
-    else
-    {
-        int __ret = 0;
-        while (__t != 0)
-        {
-            __ret += __libcpp_popcount(static_cast<unsigned long long>(__t));
-            __t >>= numeric_limits<unsigned long long>::digits;
-        }
-        return __ret;
-    }
-}
+    
 
 // integral log base 2
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 unsigned __bit_log2(_Tp __t) _NOEXCEPT
 {
     static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__bit_log2 requires an unsigned integer type");
     return numeric_limits<_Tp>::digits - 1 - __countl_zero(__t);

libcxx/include/charconv

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __itoa {
 _LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT;
 _LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;
-}
+} // namespace __itoa
 
 #ifndef _LIBCPP_CXX03_LANG
 
 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
 from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
 
 namespace __itoa
 {

 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
 {
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
     if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
         return {__tx::__convert(__value, __first), errc(0)};
-    else
-        return {__last, errc::value_too_large};
 }
 
 template <typename _Tp>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     true_type)
 {

 };
 
 template <typename _Tp>
 inline _LIBCPP_INLINE_VISIBILITY __in_pattern_result
 __in_pattern(_Tp __c, int __base)
 {
     if (__base <= 10)
         return {'0' <= __c && __c < '0' + __base, __c - '0'};
-    else if (__in_pattern(__c))
+    if (__in_pattern(__c))
         return {true, __c - '0'};
-    else if ('a' <= __c && __c < 'a' + __base - 10)
+    if ('a' <= __c && __c < 'a' + __base - 10)
         return {true, __c - 'a' + 10};
-    else
-        return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                          _Ts... __args)
 {
     auto __find_non_zero = [](_It __first, _It __last) {
         for (; __first != __last; ++__first)
             if (*__first != '0')
                 break;
         return __first;
     };
 
     auto __p = __find_non_zero(__first, __last);
     if (__p == __last || !__in_pattern(*__p, __args...))
     {
         if (__p == __first)
             return {__first, errc::invalid_argument};
-        else
-        {
-            __value = 0;
-            return {__p, {}};
-        }
-    }
 
     auto __r = __f(__p, __last, __value, __args...);
     if (__r.ec == errc::result_out_of_range)
     {
         for (; __r.ptr != __last; ++__r.ptr)
         {
             if (!__in_pattern(*__r.ptr, __args...))
                 break;

libcxx/include/chrono

 struct __is_duration<const duration<_Rep, _Period> > : true_type  {};
 
 template <class _Rep, class _Period>
 struct __is_duration<volatile duration<_Rep, _Period> > : true_type  {};
 
 template <class _Rep, class _Period>
 struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
 
-} // chrono
+} // namespace chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
                                          chrono::duration<_Rep2, _Period2> >
 {
     typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                              typename __ratio_gcd<_Period1, _Period2>::type> type;
 };
public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
 
     // special values
 
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());}
 };
 
-} // chrono
+} // namespace chrono
 
 template <class _Clock, class _Duration1, class _Duration2>
 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
                                          chrono::time_point<_Clock, _Duration2> >
 {
     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 };
 
private:
     precision       __f;
 };
 
 constexpr bool is_am(const hours& __h) noexcept { return __h >= hours( 0) && __h < hours(12); }
 constexpr bool is_pm(const hours& __h) noexcept { return __h >= hours(12) && __h < hours(24); }
 
 constexpr hours make12(const hours& __h) noexcept
 {
-    if      (__h == hours( 0)) return hours(12);
-    else if (__h <= hours(12)) return __h;
-    else                       return __h - hours(12);
+  if (__h == hours( 0))
+    return hours(12);
+  if (__h <= hours(12))
+    return __h;
+  return __h - hours(12);
 }
 
 constexpr hours make24(const hours& __h, bool __is_pm) noexcept
 {
     if (__is_pm)
         return __h == hours(12) ? __h : __h + hours(12);
-    else
-        return __h == hours(12) ? hours(0) : __h;
 }
 
 #endif // _LIBCPP_STD_VER > 17
-} // chrono
+} // namespace chrono
 
 #if _LIBCPP_STD_VER > 11
 // Suffixes for duration literals [time.duration.literals]
 inline namespace literals
 {
   inline namespace chrono_literals
   {
 
constexpr chrono::day operator ""d(unsigned long long __d) noexcept
         return chrono::day(static_cast<unsigned>(__d));
     }
 
     constexpr chrono::year operator ""y(unsigned long long __y) noexcept
     {
         return chrono::year(static_cast<int>(__y));
     }
 #endif
-}}
+} // namespace chrono_literals
+} // namespace literals
 
 namespace chrono { // hoist the literals into namespace std::chrono
    using namespace literals::chrono_literals;
-}
+} // namespace chrono
 
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 struct _FilesystemClock {

libcxx/include/cmath

 _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
     if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
         return __t * __b + (1 - __t) * __a;
 
     if (__t == 1) return __b;
     const _Fp __x = __a + __t * (__b - __a);
     if ((__t > 1) == (__b > __a))
         return __b < __x ? __x : __b;
-    else
-        return __x < __b ? __x : __b;
 }
 
 constexpr float
 lerp(float __a, float __b, float __t)                   _NOEXCEPT { return __lerp(__a, __b, __t); }
 
 constexpr double
 lerp(double __a, double __b, double __t)                _NOEXCEPT { return __lerp(__a, __b, __t); }
 

 // clamping to the integral types representable range.
 //
 // The behavior is undefined if `__r` is NaN.
 template <class _IntT, class _RealT>
 _LIBCPP_INLINE_VISIBILITY
 _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
   using _Lim = numeric_limits<_IntT>;
   const _IntT _MaxVal = __max_representable_int_for_float<_IntT, _RealT>();
-  if (__r >= ::nextafter(static_cast<_RealT>(_MaxVal), INFINITY)) {
+  if (__r >= ::nextafter(static_cast<_RealT>(_MaxVal), INFINITY))
     return _Lim::max();
-  } else if (__r <= _Lim::lowest()) {
+  if (__r <= _Lim::lowest())
     return _Lim::min();
-  }
   return static_cast<_IntT>(__r);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CMATH

libcxx/include/complex

acosh(const complex<_Tp>& __x)
     if (__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__libcpp_isnan_or_builtin(__x.imag()))
             return complex<_Tp>(abs(__x.real()), __x.imag());
         if (__libcpp_isinf_or_builtin(__x.imag()))
         {
             if (__x.real() > 0)
                 return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
-            else
-                return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
         }
         if (__x.real() < 0)
             return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
     }
     if (__libcpp_isnan_or_builtin(__x.real()))
     {
         if (__libcpp_isinf_or_builtin(__x.imag()))
inline namespace complex_literals
     {
         return { 0.0f, static_cast<float>(__im) };
     }
 
     constexpr complex<float> operator""if(unsigned long long __im)
     {
         return { 0.0f, static_cast<float>(__im) };
     }
-  }
-}
+  } // namespace complex_literals
+} // namespace literals
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPLEX

libcxx/include/exception

 template <class _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 rethrow_if_nested(const _Ep&,
                   typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
 {
 }
 
-}  // std
+} // namespace std
 
 #endif // _LIBCPP_EXCEPTION

libcxx/include/ext/__hash

template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
     : public std::unary_function<unsigned long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned long __c) const _NOEXCEPT
     {
         return __c;
     }
 };
-}
+} // namespace __gnu_cxx
 
 #endif // _LIBCPP_EXT_HASH

libcxx/include/ext/hash_map

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
-} // __gnu_cxx
+} // namespace __gnu_cxx
 
 #endif // _LIBCPP_HASH_MAP

libcxx/include/ext/hash_set

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
-} // __gnu_cxx
+} // namespace __gnu_cxx
 
 #endif // _LIBCPP_HASH_SET

libcxx/include/filesystem

*/
 
   _LIBCPP_INLINE_VISIBILITY
   path& assign(string_type&& __s) noexcept {
     __pn_ = _VSTD::move(__s);
     return *this;
   }
 
   template <class _Source>
+  // Reason: clang-tidy does not recognize enable_if
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
   _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
   operator=(const _Source& __src) {
     return this->assign(__src);
   }
 
   template <class _Source>
   _EnableIfPathable<_Source> assign(const _Source& __src) {
     __pn_.clear();

libcxx/include/initializer_list

 const _Ep*
 end(initializer_list<_Ep> __il) _NOEXCEPT
 {
     return __il.end();
 }
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
-}  // std
+} // namespace std
 
 #endif // _LIBCPP_INITIALIZER_LIST

libcxx/include/locale

if (__a != __a_end)
         typename remove_reference<decltype(errno)>::type __current_errno = errno;
         if (__current_errno == 0)
             errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
-        else if (__current_errno == ERANGE         ||
-                 __ll < numeric_limits<_Tp>::min() ||
-                 numeric_limits<_Tp>::max() < __ll)
+        if (__current_errno == ERANGE         ||
         {
             __err = ios_base::failbit;
             if (__ll > 0)
                 return numeric_limits<_Tp>::max();
-            else
-                return numeric_limits<_Tp>::min();
         }
         return static_cast<_Tp>(__ll);
     }
     __err = ios_base::failbit;
     return 0;
 }
 
 template <class _Tp>
if (__a != __a_end)
         typename remove_reference<decltype(errno)>::type __current_errno = errno;
         if (__current_errno == 0)
             errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
-        else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll)
+        if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll)
         {
             __err = ios_base::failbit;
             return numeric_limits<_Tp>::max();
         }
         _Tp __res = static_cast<_Tp>(__ll);
         if (__negate) __res = -__res;
         return __res;
     }
if (__a != __a_end)
         typename remove_reference<decltype(errno)>::type __current_errno = errno;
         if (__current_errno == 0)
             errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
-        else if (__current_errno == ERANGE)
+        if (__current_errno == ERANGE)
             __err = ios_base::failbit;
         return __ld;
     }
     __err = ios_base::failbit;
     return 0;
 }
 
 template <class _CharT, class _InputIterator>
__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
     for (__nf = __ns; __nf < __ne; ++__nf)
     {
         if (*__nf == '.')
         {
             *__oe++ = __npt.decimal_point();
             ++__nf;
             break;
         }
-        else
-            *__oe++ = __ct.widen(*__nf);
+        
     }
     __ct.widen(__nf, __ne, __oe);
     __oe += __ne - __nf;
     if (__np == __ne)
         __op = __oe;
     else
         __op = __ob + (__np - __nb);
 }

libcxx/include/mutex

recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
     return false;
 }
 
 template <class _L0, class _L1>
 int
 try_lock(_L0& __l0, _L1& __l1)
 {
     unique_lock<_L0> __u0(__l0, try_to_lock);
-    if (__u0.owns_lock())
-    {
-        if (__l1.try_lock())
-        {
-            __u0.release();
-            return -1;
-        }
-        else
-            return 1;
-    }
-    return 0;
-}
+    if (!__u0.owns_lock())
+        return 0;
+    if (!__l1.try_lock())
+        return 1;
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1, class _L2, class... _L3>
 int
 try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
 {
     int __r = 0;

libcxx/include/new

 // Enable the declaration even if the compiler doesn't support the language
 // feature.
 struct destroying_delete_t {
   explicit destroying_delete_t() = default;
 };
 inline constexpr destroying_delete_t destroying_delete{};
 #endif // _LIBCPP_STD_VER > 17
 
-}  // std
+} // namespace std
 
 #if defined(_LIBCPP_CXX03_LANG)
 #define _THROW_BAD_ALLOC throw(std::bad_alloc)
 #else
 #define _THROW_BAD_ALLOC
 #endif
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)

 void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
     (void)__align;
     return __do_deallocate_handle_size(__ptr, __size);
 #else
     if (__is_overaligned_for_new(__align)) {
       const align_val_t __align_val = static_cast<align_val_t>(__align);
       return __do_deallocate_handle_size(__ptr, __size, __align_val);
-    } else {
-      return __do_deallocate_handle_size(__ptr, __size);
     }
+    return __do_deallocate_handle_size(__ptr, __size);
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
     (void)__align;
     return __libcpp_operator_delete(__ptr);
 #else
     if (__is_overaligned_for_new(__align)) {
       const align_val_t __align_val = static_cast<align_val_t>(__align);
       return __libcpp_operator_delete(__ptr, __align_val);
-    } else {
-      return __libcpp_operator_delete(__ptr);
     }
+    return __libcpp_operator_delete(__ptr);
 #endif
 }
 
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 // Low-level helpers to call the aligned allocation and deallocation functions
 // on the target platform. This is used to implement libc++'s own memory
 // allocation routines -- if you need to allocate memory inside the library,
 // chances are that you want to use `__libcpp_allocate` instead.

libcxx/include/optional

class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
     : public exception
 {
 public:
     // Get the key function ~bad_optional_access() into the dylib
     virtual ~bad_optional_access() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
-}  // std
+} // namespace std
 
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_NORETURN
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS

libcxx/include/regex

enum error_type
     error_complexity,
     error_stack,
     __re_err_grammar,
     __re_err_empty,
     __re_err_unknown,
     __re_err_parse
 };
 
-}  // regex_constants
+} // namespace regex_constants
 
 class _LIBCPP_EXCEPTION_ABI regex_error
     : public runtime_error
 {
     regex_constants::error_type __code_;
 public:
     explicit regex_error(regex_constants::error_type __ecode);
     regex_error(const regex_error&) _NOEXCEPT = default;
basic_regex(initializer_list<value_type> __il,
         __init(__il.begin(), __il.end());
         }
 #endif // _LIBCPP_CXX03_LANG
 
 //    ~basic_regex() = default;
 
 //     basic_regex& operator=(const basic_regex&) = default;
 //     basic_regex& operator=(basic_regex&&) = default;
     _LIBCPP_INLINE_VISIBILITY
-    basic_regex& operator=(const value_type* __p)
-        {return assign(__p);}
+    basic_regex& operator=(const value_type* __p) { assign(__p); return *this; }
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    basic_regex& operator=(initializer_list<value_type> __il)
-        {return assign(__il);}
+    basic_regex& operator=(initializer_list<value_type> __il) { assign(__il); return *this; }
 #endif // _LIBCPP_CXX03_LANG
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
-        basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
-        {return assign(__p);}
+        basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p) { assign(__p); return *this; }
 
     // assign:
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(const basic_regex& __that)
         {return *this = __that;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(basic_regex&& __that) _NOEXCEPT
basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
     if (__first != __last && *__first != ']')
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         basic_string<_CharT> __start_range;
         if (__temp != __last && *__first == '[')
         {
             if (*__temp == '=')
                 return __parse_equivalence_class(++__temp, __last, __ml);
-            else if (*__temp == ':')
+            if (*__temp == ':')
                 return __parse_character_class(++__temp, __last, __ml);
-            else if (*__temp == '.')
+            if (*__temp == '.')
                 __first = __parse_collating_symbol(++__temp, __last, __start_range);
         }
         unsigned __grammar = __get_grammar(__flags_);
         if (__start_range.empty())
         {
             if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
             {
                 if (__grammar == ECMAScript)
regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
     _BidirectionalIterator __start = __match_[0].second;
     if (__match_[0].first == __match_[0].second)
     {
         if (__start == __end_)
         {
             __match_ = value_type();
             return *this;
         }
-        else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
-                                    __flags_ | regex_constants::match_not_null |
-                                    regex_constants::match_continuous))
+        if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
             return *this;
-        else
-            ++__start;
     }
     __flags_ |= regex_constants::match_prev_avail;
     if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
         __match_ = value_type();
     return *this;
 }
 
 // regex_token_iterator

libcxx/include/semaphore

public:
     }
     template <class Clock, class Duration>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire_until(chrono::time_point<Clock, Duration> const& __abs_time)
     {
         auto const current = Clock::now();
         if (current >= __abs_time)
             return try_acquire();
-        else
-            return try_acquire_for(__abs_time - current);
     }
 };
 
 using binary_semaphore = counting_semaphore<1>;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
 #endif //_LIBCPP_SEMAPHORE

libcxx/include/sstream

 basic_stringbuf<_CharT, _Traits, _Allocator>::str() const
 {
     if (__mode_ & ios_base::out)
     {
         if (__hm_ < this->pptr())
             __hm_ = this->pptr();
         return string_type(this->pbase(), __hm_, __str_.get_allocator());
     }
-    else if (__mode_ & ios_base::in)
+    if (__mode_ & ios_base::in)
         return string_type(this->eback(), this->egptr(), __str_.get_allocator());
     return string_type(__str_.get_allocator());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_stringbuf<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 {

libcxx/include/stdexcept

public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     underflow_error(const underflow_error&) _NOEXCEPT = default;
     virtual ~underflow_error() _NOEXCEPT;
 #endif
 };
 
-}  // std
+} // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_logic_error(const char*__msg)

libcxx/include/string

#endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
 
     basic_string& operator=(const basic_string& __str);
 
     template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
     basic_string& operator=(const _Tp& __t)
-        {__self_view __sv = __t; return assign(__sv);}
+        {__self_view __sv = __t; assign(__sv); return *this; }
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
      _LIBCPP_INLINE_VISIBILITY
-    basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
+    basic_string& operator=(initializer_list<value_type> __il) { assign(__il.begin(), __il.size()); return *this; }
 #endif
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) { assign(__s); return *this; }
 #if _LIBCPP_STD_VER > 20
     basic_string& operator=(nullptr_t) = delete;
 #endif
     basic_string& operator=(value_type __c);
 
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT

 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
   if (this != &__str) {
     __copy_assign_alloc(__str);
     if (!__is_long()) {
       if (!__str.__is_long()) {
         __r_.first().__r = __str.__r_.first().__r;
       } else {
-        return __assign_no_alias<true>(__str.data(), __str.size());
+        __assign_no_alias<true>(__str.data(), __str.size());
+        return *this;
       }
     } else {
-      return __assign_no_alias<false>(__str.data(), __str.size());
+      __assign_no_alias<false>(__str.data(), __str.size());
+      return *this;
     }
   }
   return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
         return basic_string<char16_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
     {
         return basic_string<char32_t> (__str, __len);
     }
-  }
-}
+  } // namespace string_literals
+} // namespace literals
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STRING

libcxx/include/string_view

basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
         return basic_string_view<char16_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char32_t> (__str, __len);
     }
-  }
-}
+  } // namespace string_view_literals
+} // namespace literals
 #endif
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STRING_VIEW

libcxx/include/system_error

public:
     _LIBCPP_INLINE_VISIBILITY
     void assign(int __val, const error_category& __cat) _NOEXCEPT
     {
         __val_ = __val;
         __cat_ = &__cat;
     }
 
     template <class _Ep>
+    // Reason: clang-tidy does not recognize enable_if
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_error_condition_enum<_Ep>::value,
             error_condition&
         >::type
         operator=(_Ep __e) _NOEXCEPT
             {*this = make_error_condition(__e); return *this;}
public:
     _LIBCPP_INLINE_VISIBILITY
     void assign(int __val, const error_category& __cat) _NOEXCEPT
     {
         __val_ = __val;
         __cat_ = &__cat;
     }
 
     template <class _Ep>
+    // Reason: clang-tidy does not recognize enable_if
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_error_code_enum<_Ep>::value,
             error_code&
         >::type
         operator=(_Ep __e) _NOEXCEPT
             {*this = make_error_code(__e); return *this;}

libcxx/include/thread

 sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
 {
     this_thread::sleep_for(__t - chrono::steady_clock::now());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 void yield() _NOEXCEPT {__libcpp_thread_yield();}
 
-}  // this_thread
+} // namespace this_thread
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_THREAD

libcxx/include/tuple

struct __find_exactly_one_checked {
     static_assert(value != __ambiguous, "type occurs more than once in type list");
 };
 
 template <class _T1>
 struct __find_exactly_one_checked<_T1> {
     static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
 };
 
-} // namespace __find_detail;
+} // namespace __find_detail
 
 template <typename _T1, typename... _Args>
 struct __find_exactly_one_t
     : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
 };
 
 template <class _T1, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY

 {
     return tuple<_Tp&...>(__t...);
 }
 
 template <class _Up>
 struct __ignore_t
 {
     template <class _Tp>
+    // Reason: has to be const qualified to swallow variables if *this is const
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const __ignore_t& operator=(_Tp&&) const {return *this;}
 };
 
 namespace {
   constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
-}
+} // namespace
 
 template <class... _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 tuple<typename __unwrap_ref_decay<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
     return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
 }

libcxx/include/type_traits

 #else
       false;
 #endif
 };
 
 template <class _Tp, class _Up>
 struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};
 
-}  // __detail
+} // namespace __detail
 
 template <class _Tp>
 struct __is_swappable
     : public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
 {
 };
 
 template <class _Tp>

libcxx/include/typeinfo

class _LIBCPP_EXCEPTION_ABI bad_typeid
     : public exception
 {
  public:
   bad_typeid() _NOEXCEPT;
   virtual ~bad_typeid() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
-}  // std
+} // namespace std
 
 #endif // defined(_LIBCPP_ABI_VCRUNTIME)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_cast();
 #else
     _VSTD::abort();
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // __LIBCPP_TYPEINFO

libcxx/include/valarray

 
 private:
     value_type* __vp_;
     size_t __size_;
     size_t __stride_;
 
 public:
     template <class _Expr>
+    // Reason: clang-tidy does not recognize enable_if
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
<
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     slice_array(slice_array const&) = default;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     const slice_array& operator=(const slice_array& __sa) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const valarray<value_type>& __va) const;
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     slice_array(const slice& __sl, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
           __size_(__sl.size()),
           __stride_(__sl.stride())
         {}
 
     template <class> friend class valarray;
     template <class> friend class sliceExpr;
 };
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 const slice_array<_Tp>&
 slice_array<_Tp>::operator=(const slice_array& __sa) const
 {
     value_type* __t = __vp_;
     const value_type* __s = __sa.__vp_;
     for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
         *__t = *__s;
     return *this;
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 template <class _Expr>
 inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t = __v[__i];
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline void
 slice_array<_Tp>::operator=(const valarray<value_type>& __va) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
         *__t = __va[__i];
 }

 >::type
 slice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t >>= __v[__i];
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 void
 slice_array<_Tp>::operator=(const value_type& __x) const
 {
     value_type* __t = __vp_;
     for (size_t __n = __size_; __n; --__n, __t += __stride_)
         *__t = __x;
public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
     template <class _Expr>
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
public:
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     const gslice_array& operator=(const gslice_array& __ga) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
     gslice_array(const gslice_array&)            = default;
 
 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_))
         {}
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 template <class _Expr>
 inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type

 gslice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] >>= __v[__j];
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 const gslice_array<_Tp>&
 gslice_array<_Tp>::operator=(const gslice_array& __ga) const
 {
     typedef const size_t* _Ip;
     const value_type* __s = __ga.__vp_;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
             __i != __e; ++__i, ++__j)
         __vp_[*__i] = __s[*__j];
     return *this;
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 void
 gslice_array<_Tp>::operator=(const value_type& __x) const
 {
     typedef const size_t* _Ip;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
         __vp_[*__i] = __x;
 }
 
 // mask_array
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS mask_array
 {
 public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
     template <class _Expr>
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
<
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     mask_array(const mask_array&) = default;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     const mask_array& operator=(const mask_array& __ma) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
           {
               size_t __j = 0;
               for (size_t __i = 0; __i < __vb.size(); ++__i)
                   if (__vb[__i])
                       __1d_[__j++] = __i;
           }
 
     template <class> friend class valarray;
 };
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 template <class _Expr>
 inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type

 >::type
 mask_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 const mask_array<_Tp>&
 mask_array<_Tp>::operator=(const mask_array& __ma) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
     return *this;
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 void
 mask_array<_Tp>::operator=(const value_type& __x) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __x;
public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
     template <class _Expr>
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
<
         __is_val_expr<_Expr>::value,
         void
     >::type
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     indirect_array(const indirect_array&) = default;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     const indirect_array& operator=(const indirect_array& __ia) const;
 
+    // Reason: return type is required by C++ standard
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 private:
      _LIBCPP_INLINE_VISIBILITY
    indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __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))
         {}
 
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 template <class _Expr>
 inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type

 >::type
 indirect_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 const indirect_array<_Tp>&
 indirect_array<_Tp>::operator=(const indirect_array& __ia) const
 {
     typedef const size_t* _Ip;
     const value_type* __s = __ia.__vp_;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
             __i != __e; ++__i, ++__j)
         __vp_[*__i] = __s[*__j];
     return *this;
 }
 
+// Reason: return type is required by C++ standard
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
 template <class _Tp>
 inline
 void
 indirect_array<_Tp>::operator=(const value_type& __x) const
 {
     typedef const size_t* _Ip;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
         __vp_[*__i] = __x;
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 != _VSTD::addressof(__v))
-        return __assign_range(__v.__begin_, __v.__end_);
+        __assign_range(__v.__begin_, __v.__end_);
     return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
 {
     __clear(size());
     __begin_ = __v.__begin_;
     __end_ = __v.__end_;
     __v.__begin_ = nullptr;
     __v.__end_ = nullptr;
     return *this;
 }
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(initializer_list<value_type> __il)
 {
-    return __assign_range(__il.begin(), __il.end());
+    __assign_range(__il.begin(), __il.end());
+    return *this;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const value_type& __x)