[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 ↗

(On Diff #391151)

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 ↗

(On Diff #391151)

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–2675

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

70

This change LGTM.

libcxx/include/__functional/bind.h

73 ↗

(On Diff #391151)

+1

libcxx/include/__memory/auto_ptr.h

41–42 ↗

(On Diff #391151)

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–2675

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

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

libcxx/include/regex

2664–2675

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,-misc-unconventional-assign-operator'

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

 template <class _ForwardIterator, class _Compare>
 _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
   static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
         "std::minmax_element requires a ForwardIterator");
   pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
-  if (__first != __last)
-  {
-      if (++__first != __last)
-      {
-          if (__comp(*__first, *__result.first))
-              __result.first = __first;
-          else
-              __result.second = __first;
-          while (++__first != __last)
-          {
-              _ForwardIterator __i = __first;
-              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;
-                  }
-              }
-          }
-      }
-  }
+  if (__first == __last || ++__first == __last)
+    return __result;
+
+
   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
             *__seg_ |= __mask_;
         else
             *__seg_ &= ~__mask_;
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
         {return operator=(static_cast<bool>(__x));}
 
     _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/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 *);

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/__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/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

 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

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
 } // namespace chrono
 
 #if _LIBCPP_STD_VER > 11
 // Suffixes for duration literals [time.duration.literals]
 inline namespace literals

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()))

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

 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/regex

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);}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& operator=(initializer_list<value_type> __il)
         {return assign(__il);}
 #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);}
 
     // 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)
 {