[libc++] [C++20] [P0482] Add missing tests and synopses for char8_t.

[curdeius]

Summary

Left to finish P0482:

• <cuchar> header.
• Parts of <memory_resource> concerning char8_t. Also, tests for hash<pmr::*string>.

[curdeius]

@ldionne, I've checked all the tests (hopefully not missing anything) and there's nothing else left in P0482 apart from the missing parts listed in the summary.

[• Quuxplusone]

LGTM FWIW.

libcxx/test/std/strings/basic.string.hash/char_type_hash.fail.cpp

63

It might arguably be clearer to say

std::hash<str_t>
        h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
    // expected-error@-2 {{call to implicitly-deleted default constructor}}
#endif

but I have no strong feelings. (I just now learned that expected-error@-2 5 ... is valid syntax.)

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

32

Cute that u8streampos and u16streampos are both just typedefs for std::fpos<std::mbstate_t>, so we can mix them up and C++ doesn't care. ;P

[ldionne]

Thanks a lot for working on this! Let me know if you'd like to pick up D97870.

[curdeius]

libcxx/test/std/strings/basic.string.hash/char_type_hash.fail.cpp

63

Indeed, will change when landing (hopefully not breaking anything).

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

32

Yeah, I laughed the moment I saw this :).

libcxx/include/__string

struct char_traits
     static constexpr char_type to_char_type(int_type c) noexcept;
     static constexpr int_type  to_int_type(char_type c) noexcept;
     static constexpr bool      eq_int_type(int_type c1, int_type c2) noexcept;
     static constexpr int_type  eof() noexcept;
 };
 
 template <> struct char_traits<char>;
 template <> struct char_traits<wchar_t>;
-template <> struct char_traits<char8_t>;  // c++20
+template <> struct char_traits<char8_t>;  // C++20
+template <> struct char_traits<char16_t>;
+template <> struct char_traits<char32_t>;
 
 }  // std
 
 */
 
 #include <__config>
 #include <algorithm>  // for search and min
 #include <cstdio>     // for EOF

libcxx/include/iosfwd

 typedef basic_stringstream<wchar_t>  wstringstream;
 
 typedef basic_filebuf<wchar_t>       wfilebuf;
 typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
 template <class state> class fpos;
-typedef fpos<char_traits<char>::state_type>    streampos;
-typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
+using streampos  = fpos<char_traits<char>::state_type>;
+using wstreampos = fpos<char_traits<wchar_t>::state_type>;
+using u8streampos = fpos<char_traits<char8_t>::state_type>; // C++20
+using u16streampos = fpos<char_traits<char16_t>::state_type>;
+using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
 }  // std
 
 */
 
 #include <__config>
 #include <wchar.h>  // for mbstate_t
 

libcxx/include/string

struct char_traits
     static constexpr char_type to_char_type(int_type c) noexcept;
     static constexpr int_type  to_int_type(char_type c) noexcept;
     static constexpr bool      eq_int_type(int_type c1, int_type c2) noexcept;
     static constexpr int_type  eof() noexcept;
 };
 
 template <> struct char_traits<char>;
 template <> struct char_traits<wchar_t>;
+template <> struct char_traits<char8_t>;  // C++20
+template <> struct char_traits<char16_t>;
+template <> struct char_traits<char32_t>;
 
 template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 class basic_string
 {
 public:
 // types:
     typedef traits traits_type;
     typedef typename traits_type::char_type value_type;

 typename basic_string<charT, traits, Allocator>::size_type
 erase(basic_string<charT, traits, Allocator>& c, const U& value);    // C++20
 template<class charT, class traits, class Allocator, class Predicate>
 typename basic_string<charT, traits, Allocator>::size_type
 erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
 
 typedef basic_string<char>    string;
 typedef basic_string<wchar_t> wstring;
+typedef basic_string<char8_t> u8string; // C++20
 typedef basic_string<char16_t> u16string;
 typedef basic_string<char32_t> u32string;
 
 int                stoi  (const string& str, size_t* idx = nullptr, int base = 10);
 long               stol  (const string& str, size_t* idx = nullptr, int base = 10);
 unsigned long      stoul (const string& str, size_t* idx = nullptr, int base = 10);
 long long          stoll (const string& str, size_t* idx = nullptr, int base = 10);
 unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);

 wstring to_wstring(unsigned long val);
 wstring to_wstring(long long val);
 wstring to_wstring(unsigned long long val);
 wstring to_wstring(float val);
 wstring to_wstring(double val);
 wstring to_wstring(long double val);
 
 template <> struct hash<string>;
+template <> struct hash<u8string>; // C++20
 template <> struct hash<u16string>;
 template <> struct hash<u32string>;
 template <> struct hash<wstring>;
 
 basic_string<char>     operator "" s( const char *str,     size_t len ); // C++14
 basic_string<wchar_t>  operator "" s( const wchar_t *str,  size_t len ); // C++14
+basic_string<char8_t>  operator "" s( const char8_t *str,  size_t len ); // C++20
 basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
 
 }  // std
 
 */
 
 #include <__config>

libcxx/include/string_view

namespace std {
     // 7.10, Inserters and extractors
     template<class charT, class traits>
       basic_ostream<charT, traits>&
         operator<<(basic_ostream<charT, traits>& os,
                    basic_string_view<charT, traits> str);
 
     // basic_string_view typedef names
     typedef basic_string_view<char> string_view;
+    typedef basic_string_view<char8_t> u8string_view; // C++20
     typedef basic_string_view<char16_t> u16string_view;
     typedef basic_string_view<char32_t> u32string_view;
     typedef basic_string_view<wchar_t> wstring_view;
 
     template<class charT, class traits = char_traits<charT>>
     class basic_string_view {
       public:
       // types
namespace std {
      private:
       const_pointer data_;  // exposition only
       size_type     size_;  // exposition only
     };
 
   // 7.11, Hash support
   template <class T> struct hash;
   template <> struct hash<string_view>;
+  template <> struct hash<u8string_view>; // C++20
   template <> struct hash<u16string_view>;
   template <> struct hash<u32string_view>;
   template <> struct hash<wstring_view>;
 
   constexpr basic_string_view<char>     operator "" sv( const char *str,     size_t len ) noexcept;
   constexpr basic_string_view<wchar_t>  operator "" sv( const wchar_t *str,  size_t len ) noexcept;
+  constexpr basic_string_view<char8_t>  operator "" sv( const char8_t *str,  size_t len ) noexcept; // C++20
   constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 

libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp

static_assert(std::numeric_limits<const volatile T>::is_specialized,
                  "std::numeric_limits<const volatile T>::is_specialized");
 }
 
 int main(int, char**)
 {
     test<bool>();
     test<char>();
     test<wchar_t>();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    test<char8_t>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<signed char>();
     test<unsigned char>();
     test<signed short>();
     test<unsigned short>();

libcxx/test/std/strings/basic.string.hash/char_type_hash.fail.cpp

static inline bool eq_int_type(int_type __c1, int_type __c2) {
         return __c1 == __c2;
     }
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string<CharT, trait<CharT> > str_t;
-    std::hash<str_t>
-        h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+    std::hash<str_t> h;
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    // expected-error-re@-2 5 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+#else
+    // expected-error-re@-4 4 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+#endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    test<char8_t>();
+#endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }

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 char8_t        char_type;
 // typedef unsigned int   int_type;
 // typedef streamoff      off_type;
-// typedef u16streampos   pos_type;
+// typedef u8streampos    pos_type;
 // typedef mbstate_t      state_type;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     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::u16streampos>::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), "");
 #endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.hash/char_type.hash.fail.cpp

static inline bool eq_int_type(int_type __c1, int_type __c2) {
         return __c1 == __c2;
     }
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string_view<CharT, trait<CharT> > strv_t;
-    std::hash<strv_t>
-        h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+    std::hash<strv_t> h;
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    // expected-error-re@-2 5 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+#else
+    // expected-error-re@-4 4 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
+#endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    test<char8_t>();
+#endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }