[NFC][libc++] char_traits code cleanups.

[Mordante]

Summary

These cleanups were identified while working on D130295.

[Mordante]

Rebased to test CI before landing.

[Mordante]

Test CI.

[Mordante]

Fix build.

[philnik]

Thanks for the cleanup!

libcxx/include/__string/char_traits.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS char_traits
 {
-    typedef _CharT    char_type;
-    typedef int       int_type;
-    typedef streamoff off_type;
-    typedef streampos pos_type;
-    typedef mbstate_t state_type;
+    using char_type  = _CharT;
+    using int_type   = int;
+    using off_type   = streamoff;
+    using pos_type   = streampos;
+    using state_type = mbstate_t;
 
     static inline void _LIBCPP_CONSTEXPR_SINCE_CXX17
         assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 
#endif
   return __dest;
 }
 
 // char_traits<char>
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char>
 {
-    typedef char      char_type;
-    typedef int       int_type;
-    typedef streamoff off_type;
-    typedef streampos pos_type;
-    typedef mbstate_t state_type;
+    using char_type           = char;
+    using int_type            = int;
+    using off_type            = streamoff;
+    using pos_type            = streampos;
+    using state_type          = mbstate_t;
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif
 
     static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
             {return __c1 == __c2;}

 
 
 // char_traits<wchar_t>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
 {
-    typedef wchar_t   char_type;
-    typedef wint_t    int_type;
-    typedef streamoff off_type;
-    typedef streampos pos_type;
-    typedef mbstate_t state_type;
-#  if _LIBCPP_STD_VER > 17
+    using char_type           = wchar_t;
+    using int_type            = wint_t;
+    using off_type            = streamoff;
+    using pos_type            = streampos;
+    using state_type          = mbstate_t;
+#if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
-#  endif
+#endif
 
     static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 

 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
 {
-    typedef char8_t        char_type;
-    typedef unsigned int   int_type;
-    typedef streamoff      off_type;
-    typedef u8streampos    pos_type;
-    typedef mbstate_t      state_type;
-#  if _LIBCPP_STD_VER > 17
+    using char_type           = char8_t;
+    using int_type            = unsigned int;
+    using off_type            = streamoff;
+    using pos_type            = u8streampos;
+    using state_type          = mbstate_t;
+#if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
-#  endif
+#endif
 
     static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
         {__c1 = __c2;}
     static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
         {return __c1 == __c2;}
     static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
         {return __c1 < __c2;}
 
char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
     return nullptr;
 }
 
 #endif // _LIBCPP_HAS_NO_CHAR8_T
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
 {
-    typedef char16_t       char_type;
-    typedef uint_least16_t int_type;
-    typedef streamoff      off_type;
-    typedef u16streampos   pos_type;
-    typedef mbstate_t      state_type;
+    using char_type           = char16_t;
+    using int_type            = uint_least16_t;
+    using off_type            = streamoff;
+    using pos_type            = u16streampos;
+    using state_type          = mbstate_t;
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif
 
     static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
for (; __n; --__n)
         ++__s;
     }
     return nullptr;
 }
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
 {
-    typedef char32_t       char_type;
-    typedef uint_least32_t int_type;
-    typedef streamoff      off_type;
-    typedef u32streampos   pos_type;
-    typedef mbstate_t      state_type;
+    using char_type           = char32_t;
+    using int_type            = uint_least32_t;
+    using off_type            = streamoff;
+    using pos_type            = u32streampos;
+    using state_type          = mbstate_t;
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif
 
     static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// template<> struct char_traits<char>
+
+// using char_type           = char;
+// using int_type            = int;
+// using off_type            = streamoff;
+// using pos_type            = streampos;
+// using state_type          = mbstate_t;
+// using comparison_category = strong_ordering;
+
+#include <string>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_same<std::char_traits<char>::char_type, char>::value, "");
+static_assert(std::is_same<std::char_traits<char>::int_type, int>::value, "");
+static_assert(std::is_same<std::char_traits<char>::off_type, std::streamoff>::value, "");
+static_assert(std::is_same<std::char_traits<char>::pos_type, std::streampos>::value, "");
+static_assert(std::is_same<std::char_traits<char>::state_type, std::mbstate_t>::value, "");
+#if TEST_STD_VER > 17
+static_assert(std::is_same_v<std::char_traits<char>::comparison_category, std::strong_ordering>);
+#endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <string>
-
-// template<> struct char_traits<char>
-
-// typedef char      char_type;
-// typedef int       int_type;
-// typedef streamoff off_type;
-// typedef streampos pos_type;
-// typedef mbstate_t state_type;
-// using comparison_category = strong_ordering;
-
-#include <string>
-#include <type_traits>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    static_assert((std::is_same<std::char_traits<char>::char_type, char>::value), "");
-    static_assert((std::is_same<std::char_traits<char>::int_type, int>::value), "");
-    static_assert((std::is_same<std::char_traits<char>::off_type, std::streamoff>::value), "");
-    static_assert((std::is_same<std::char_traits<char>::pos_type, std::streampos>::value), "");
-    static_assert((std::is_same<std::char_traits<char>::state_type, std::mbstate_t>::value), "");
-#if TEST_STD_VER > 17
-    static_assert(std::is_same_v<std::char_traits<char>::comparison_category, std::strong_ordering>);
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// template<> struct char_traits<char16_t>
+
+// using char_type           = char16_t;
+// using int_type            = uint_least16_t;
+// using off_type            = streamoff;
+// using pos_type            = u16streampos;
+// using state_type          = mbstate_t;
+// using comparison_category = strong_ordering;
+
+#include <string>
+#include <type_traits>
+#include <cstdint>
+
+#include "test_macros.h"
+
+static_assert(std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value, "");
+static_assert(std::is_same<std::char_traits<char16_t>::int_type, std::uint_least16_t>::value, "");
+static_assert(std::is_same<std::char_traits<char16_t>::off_type, std::streamoff>::value, "");
+static_assert(std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value, "");
+static_assert(std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value, "");
+#if TEST_STD_VER > 17
+static_assert(std::is_same_v<std::char_traits<char16_t>::comparison_category, std::strong_ordering>);
+#endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <string>
-
-// template<> struct char_traits<char16_t>
-
-// typedef char16_t       char_type;
-// typedef uint_least16_t int_type;
-// typedef streamoff      off_type;
-// typedef u16streampos   pos_type;
-// typedef mbstate_t      state_type;
-// using comparison_category = strong_ordering;
-
-#include <string>
-#include <type_traits>
-#include <cstdint>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    static_assert((std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value), "");
-    static_assert((std::is_same<std::char_traits<char16_t>::int_type, std::uint_least16_t>::value), "");
-    static_assert((std::is_same<std::char_traits<char16_t>::off_type, std::streamoff>::value), "");
-    static_assert((std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value), "");
-    static_assert((std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value), "");
-#if TEST_STD_VER > 17
-    static_assert(std::is_same_v<std::char_traits<char16_t>::comparison_category, std::strong_ordering>);
-#endif
-
-    return 0;
-}

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char32_t>
 
-// typedef char32_t       char_type;
-// typedef uint_least32_t int_type;
-// typedef streamoff      off_type;
-// typedef u32streampos   pos_type;
-// typedef mbstate_t      state_type;
+// using char_type           = char32_t;
+// using int_type            = uint_least32_t;
+// using off_type            = streamoff;
+// using pos_type            = u32streampos;
+// using state_type          = mbstate_t;
 // using comparison_category = strong_ordering;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
-static_assert((std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value), "");
-static_assert((std::is_same<std::char_traits<char32_t>::int_type, std::uint_least32_t>::value), "");
-static_assert((std::is_same<std::char_traits<char32_t>::off_type, std::streamoff>::value), "");
-static_assert((std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value), "");
-static_assert((std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value), "");
+static_assert(std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value, "");
+static_assert(std::is_same<std::char_traits<char32_t>::int_type, std::uint_least32_t>::value, "");
+static_assert(std::is_same<std::char_traits<char32_t>::off_type, std::streamoff>::value, "");
+static_assert(std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value, "");
+static_assert(std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value, "");
 #if TEST_STD_VER > 17
 static_assert(std::is_same_v<std::char_traits<char32_t>::comparison_category, std::strong_ordering>);
 #endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<> struct char_traits<char8_t>
+
+// using char_type           = char8_t;
+// using int_type            = unsigned int;
+// using off_type            = streamoff;
+// using pos_type            = u8streampos;
+// using state_type          = mbstate_t;
+// using comparison_category = strong_ordering;
+
+#include <string>
+#include <type_traits>
+#include <cstdint>
+
+#include "test_macros.h"
+
+#if TEST_HAS_NO_CHAR8_T
+static_assert(std::is_same<std::char_traits<char8_t>::char_type, char8_t>::value);
+static_assert(std::is_same<std::char_traits<char8_t>::int_type, unsigned int>::value);
+static_assert(std::is_same<std::char_traits<char8_t>::off_type, std::streamoff>::value);
+static_assert(std::is_same<std::char_traits<char8_t>::pos_type, std::u8streampos>::value);
+static_assert(std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value);
+static_assert(std::is_same_v<std::char_traits<char8_t>::comparison_category, std::strong_ordering>);
+#endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// <string>
-
-// template<> struct char_traits<char8_t>
-
-// typedef char8_t        char_type;
-// typedef unsigned int   int_type;
-// typedef streamoff      off_type;
-// typedef u8streampos    pos_type;
-// typedef mbstate_t      state_type;
-// using comparison_category = strong_ordering;
-
-#include <string>
-#include <type_traits>
-#include <cstdint>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-#ifndef TEST_HAS_NO_CHAR8_T
-    static_assert((std::is_same<std::char_traits<char8_t>::char_type,  char8_t>::value), "");
-    static_assert((std::is_same<std::char_traits<char8_t>::int_type,   unsigned int>::value), "");
-    static_assert((std::is_same<std::char_traits<char8_t>::off_type,   std::streamoff>::value), "");
-    static_assert((std::is_same<std::char_traits<char8_t>::pos_type,   std::u8streampos>::value), "");
-    static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
-    static_assert(std::is_same_v<std::char_traits<char8_t>::comparison_category, std::strong_ordering>);
-#endif
-
-  return 0;
-}

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// template<> struct char_traits<wchar_t>
+
+// using char_type           = wchar_t;
+// using int_type            = wint_t;
+// using off_type            = streamoff;
+// using pos_type            = streampos;
+// using state_type          = mbstate_t;
+// using comparison_category = strong_ordering;
+
+// UNSUPPORTED: no-wide-characters
+
+#include <string>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value, "");
+static_assert(std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value, "");
+static_assert(std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value, "");
+static_assert(std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value, "");
+static_assert(std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value, "");
+#if TEST_STD_VER > 17
+static_assert(std::is_same_v<std::char_traits<wchar_t>::comparison_category, std::strong_ordering>);
+#endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <string>
-
-// template<> struct char_traits<wchar_t>
-
-// typedef wchar_t   char_type;
-// typedef int       int_type;
-// typedef streamoff off_type;
-// typedef streampos pos_type;
-// typedef mbstate_t state_type;
-// using comparison_category = strong_ordering;
-
-// UNSUPPORTED: no-wide-characters
-
-#include <string>
-#include <type_traits>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
-    static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), "");
-    static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), "");
-    static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), "");
-    static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), "");
-#if TEST_STD_VER > 17
-    static_assert(std::is_same_v<std::char_traits<wchar_t>::comparison_category, std::strong_ordering>);
-#endif
-
-  return 0;
-}