[libc++] Move preferred_name declarations into the forward declaring headers and add pmr preferred names

[philnik]

Summary

We currently define the preferred names in multiple places. basic_string and basic_string_view also have a lot of aliases, which makes the declarations quite long. So let's only add the preferred names in forward-declaring headers to make the implementation more readable and have all the preferred names in one place.

[philnik]

• Generate files

[philnik]

• Rebased
• Try to fix CI

[philnik]

Fix patch

[philnik]

• Try to fix CI

[philnik]

Fix diff

[philnik]

Try to fix CI

[philnik]

Rebased onto main

[EricWF]

This change needs a description explaining it's rational.

[EricWF]

libcxx/include/__fwd/string.h

58

Second declaration here.

libcxx/include/regex

6848

This would have caused anybody including regex without wchar_t to fail to build, right?

How did we not catch that before?

libcxx/include/string

648–649

Aren't we double defining this typedef?

659

What happened to _LIBCPP_TEMPLATE_VIS?

libcxx/include/string_view

207

Shouldn't this directly include the forward decl header?

[philnik]

Address comments and try to fix CI

libcxx/include/string

648–649

yes, good catch!

659

Looks like I removed that accidentally. Is there any way to test for it currently?

libcxx/include/string_view

207

It does, in line 210.

[philnik]

Fix CI

[ldionne]

libcxx/include/regex

6848

The problem here is that we don't have a true C library that does not provide wchar_t. So yes, this would have failed indeed and we would have caught it when building for a platform that truly doesn't provide wchar_t. This is a known hole in our CI coverage, but I think we'd need a custom C library in order to catch this (or an upstream platform that does not provide wchar_t, which is equivalent).

libcxx/include/CMakeLists.txt

set(files
   __functional/reference_wrapper.h
   __functional/unary_function.h
   __functional/unary_negate.h
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __fwd/array.h
   __fwd/get.h
   __fwd/hash.h
+  __fwd/memory_resource.h
   __fwd/pair.h
   __fwd/span.h
+  __fwd/string.h
   __fwd/string_view.h
   __fwd/tuple.h
   __hash_table
   __ios/fpos.h
   __iterator/access.h
   __iterator/advance.h
   __iterator/back_insert_iterator.h
   __iterator/bounded_iter.h

libcxx/include/__fwd/memory_resource.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_MEMORY_RESOURCE_H
+#define _LIBCPP___FWD_MEMORY_RESOURCE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+template <class _ValueType>
+class _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_MEMORY_RESOURCE_H

libcxx/include/__fwd/string.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_STRING_H
+#define _LIBCPP___FWD_STRING_H
+
+#include <__config>
+#include <__fwd/memory_resource.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS char_traits;
+template <>
+struct char_traits<char>;
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+template <>
+struct char_traits<char8_t>;
+#endif
+
+template <>
+struct char_traits<char16_t>;
+template <>
+struct char_traits<char32_t>;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+struct char_traits<wchar_t>;
+#endif
+
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS allocator;
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
+class _LIBCPP_TEMPLATE_VIS basic_string;
+
+using string = basic_string<char>;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wstring = basic_string<wchar_t>;
+#endif
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+using u8string = basic_string<char8_t>;
+#endif
+
+using u16string = basic_string<char16_t>;
+using u32string = basic_string<char32_t>;
+
+#if _LIBCPP_STD_VER >= 17
+
+namespace pmr {
+template <class _CharT, class _Traits = char_traits<_CharT>>
+using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+
+using string = basic_string<char>;
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wstring = basic_string<wchar_t>;
+#  endif
+
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+using u8string = basic_string<char8_t>;
+#  endif
+
+using u16string = basic_string<char16_t>;
+using u32string = basic_string<char32_t>;
+
+} // namespace pmr
+
+#endif // _LIBCPP_STD_VER >= 17
+
+// clang-format off
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_PREFERRED_NAME(string)
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      _LIBCPP_PREFERRED_NAME(wstring)
+#endif
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+      _LIBCPP_PREFERRED_NAME(u8string)
+#endif
+      _LIBCPP_PREFERRED_NAME(u16string)
+      _LIBCPP_PREFERRED_NAME(u32string)
+#if _LIBCPP_STD_VER >= 17
+      _LIBCPP_PREFERRED_NAME(pmr::string)
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      _LIBCPP_PREFERRED_NAME(pmr::wstring)
+#  endif
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+      _LIBCPP_PREFERRED_NAME(pmr::u8string)
+#  endif
+      _LIBCPP_PREFERRED_NAME(pmr::u16string)
+      _LIBCPP_PREFERRED_NAME(pmr::u32string)
+#endif
+      basic_string;
+// clang-format on
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_STRING_H

libcxx/include/__fwd/string_view.h

 typedef basic_string_view<char8_t>  u8string_view;
 #endif
 typedef basic_string_view<char16_t> u16string_view;
 typedef basic_string_view<char32_t> u32string_view;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 typedef basic_string_view<wchar_t>  wstring_view;
 #endif
 
+// clang-format off
+template <class _CharT, class _Traits>
+class _LIBCPP_PREFERRED_NAME(string_view)
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      _LIBCPP_PREFERRED_NAME(wstring_view)
+#endif
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+      _LIBCPP_PREFERRED_NAME(u8string_view)
+#endif
+      _LIBCPP_PREFERRED_NAME(u16string_view)
+      _LIBCPP_PREFERRED_NAME(u32string_view)
+      basic_string_view;
+// clang-format on
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_STRING_VIEW_H

libcxx/include/iosfwd

 using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/string.h>
 #include <__mbstate_t.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS ios_base;
 
-template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
-template<> struct char_traits<char>;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-template<> struct char_traits<char8_t>;
-#endif
-template<> struct char_traits<char16_t>;
-template<> struct char_traits<char32_t>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template<> struct char_traits<wchar_t>;
-#endif
-
-template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
-
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_ios;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_streambuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_istream;
 template <class _CharT, class _Traits = char_traits<_CharT> >

 
 #if defined(_NEWLIB_VERSION)
 // On newlib, off_t is 'long int'
 typedef long int streamoff;         // for char_traits in <string>
 #else
 typedef long long streamoff;        // for char_traits in <string>
 #endif
 
-template <class _CharT,             // for <stdexcept>
-          class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS basic_string;
-typedef basic_string<char, char_traits<char>, allocator<char> > string;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
-#endif
-
-template <class _CharT, class _Traits, class _Allocator>
-    class _LIBCPP_PREFERRED_NAME(string) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wstring)) basic_string;
-
 // Include other forward declarations here
 template <class _Tp, class _Alloc = allocator<_Tp> >
 class _LIBCPP_TEMPLATE_VIS vector;
 
 template <class _CharT, class _Traits>
 class __save_flags
 {
     typedef basic_ios<_CharT, _Traits> __stream_type;

libcxx/include/module.modulemap.in

module memory {
     }
   }
   module memory_resource {
     header "memory_resource"
     export *
 
     module __memory_resource {
       module memory_resource              { private header "__memory_resource/memory_resource.h" }
+      module memory_resource_fwd          { private header "__fwd/memory_resource.h" }
       module monotonic_buffer_resource    { private header "__memory_resource/monotonic_buffer_resource.h" }
       module polymorphic_allocator        { private header "__memory_resource/polymorphic_allocator.h" }
       module pool_options                 { private header "__memory_resource/pool_options.h" }
       module synchronized_pool_resource   { private header "__memory_resource/synchronized_pool_resource.h" }
       module unsynchronized_pool_resource { private header "__memory_resource/unsynchronized_pool_resource.h" }
     }
   }
   module mutex {

   }
   module string {
     header "string"
     export initializer_list
     export string_view
     module __string {
       module char_traits           { private header "__string/char_traits.h" }
       module extern_template_lists { private header "__string/extern_template_lists.h" }
+      module string_fwd            { private header "__fwd/string.h" }
     }
     export *
   }
   module string_view {
     header "string_view"
     export initializer_list
     export *
     module string_view_fwd { private header "__fwd/string_view.h" }

libcxx/include/regex

 
 #if _LIBCPP_STD_VER > 14
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _BidirT>
 using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
 
 using cmatch  = match_results<const char*>;
-using wcmatch = match_results<const wchar_t*>;
 using smatch  = match_results<std::pmr::string::const_iterator>;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wcmatch = match_results<const wchar_t*>;
 using wsmatch = match_results<std::pmr::wstring::const_iterator>;
+#endif
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/string

 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
+#include <__fwd/string.h>
 #include <__ios/fpos.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>

 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
-#include <iosfwd>
 #include <limits>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>

 struct __string_is_trivial_iterator<__wrap_iter<_Iter> >
     : public __string_is_trivial_iterator<_Iter> {};
 
 template <class _CharT, class _Traits, class _Tp>
 struct __can_be_converted_to_string_view : public _BoolConstant<
       is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
      !is_convertible<const _Tp&, const _CharT*>::value
     > {};
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-typedef basic_string<char8_t> u8string;
-#endif
-typedef basic_string<char16_t> u16string;
-typedef basic_string<char32_t> u32string;
-
 struct __uninitialized_size_tag {};
 
 template<class _CharT, class _Traits, class _Allocator>
-class
-    _LIBCPP_TEMPLATE_VIS
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-    _LIBCPP_PREFERRED_NAME(u8string)
-#endif
-    _LIBCPP_PREFERRED_NAME(u16string)
-    _LIBCPP_PREFERRED_NAME(u32string)
-    basic_string
+class basic_string
 {
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
     typedef _CharT                                       value_type;
     typedef _Allocator                                   allocator_type;
     typedef allocator_traits<allocator_type>             __alloc_traits;

 inline constexpr bool __format::__enable_insertable<std::basic_string<wchar_t>> = true;
 #endif
 #endif
 
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
-namespace pmr {
-template <class _CharT, class _TraitsT = std::char_traits<_CharT>>
-using basic_string = std::basic_string<_CharT, _TraitsT, polymorphic_allocator<_CharT>>;
-
-using string    = basic_string<char>;
-using u16string = basic_string<char16_t>;
-using u32string = basic_string<char32_t>;
-using wstring   = basic_string<wchar_t>;
-} // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
-#endif
-
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #  include <vector>
 #endif
 
 #endif // _LIBCPP_STRING

libcxx/include/string_view

 
 }  // namespace std
 
 
 */
 
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__fwd/string_view.h>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>

 template <class _Traits>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
   // This needs to be a single statement for C++11 constexpr
   return _LIBCPP_ASSERT(__s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"), _Traits::length(__s);
 }
 
 template<class _CharT, class _Traits>
-class
-    _LIBCPP_PREFERRED_NAME(string_view)
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-    _LIBCPP_PREFERRED_NAME(u8string_view)
-#endif
-    _LIBCPP_PREFERRED_NAME(u16string_view)
-    _LIBCPP_PREFERRED_NAME(u32string_view)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wstring_view))
-    basic_string_view {
+class basic_string_view {
 public:
     // types
     typedef _Traits                                    traits_type;
     typedef _CharT                                     value_type;
     typedef _CharT*                                    pointer;
     typedef const _CharT*                              const_pointer;
     typedef _CharT&                                    reference;
     typedef const _CharT&                              const_reference;

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__functional/reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__functional/reference_wrapper.h'}}
 #include <__functional/unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_function.h'}}
 #include <__functional/unary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_negate.h'}}
 #include <__functional/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unwrap_ref.h'}}
 #include <__functional/weak_result_type.h> // expected-error@*:* {{use of private header from outside its module: '__functional/weak_result_type.h'}}
 #include <__fwd/array.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/array.h'}}
 #include <__fwd/get.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/get.h'}}
 #include <__fwd/hash.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/hash.h'}}
+#include <__fwd/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/memory_resource.h'}}
 #include <__fwd/pair.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/pair.h'}}
 #include <__fwd/span.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/span.h'}}
+#include <__fwd/string.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string.h'}}
 #include <__fwd/string_view.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string_view.h'}}
 #include <__fwd/tuple.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/tuple.h'}}
 #include <__ios/fpos.h> // expected-error@*:* {{use of private header from outside its module: '__ios/fpos.h'}}
 #include <__iterator/access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/access.h'}}
 #include <__iterator/advance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/advance.h'}}
 #include <__iterator/back_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/back_insert_iterator.h'}}
 #include <__iterator/bounded_iter.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/bounded_iter.h'}}
 #include <__iterator/common_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/common_iterator.h'}}

libcxx/test/std/utilities/utility/mem.res/mem.res.aliases/header_regex_synop.pass.cpp

void test_match_result_typedef() {
   using PmrMR = std::pmr::match_results<Iter>;
   static_assert(std::is_same<StdMR, PmrMR>::value, "");
   static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
 }
 
 int main(int, char**) {
   {
     test_match_result_typedef<const char*, std::pmr::cmatch>();
-    test_match_result_typedef<const wchar_t*, std::pmr::wcmatch>();
     test_match_result_typedef<std::pmr::string::const_iterator, std::pmr::smatch>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test_match_result_typedef<const wchar_t*, std::pmr::wcmatch>();
     test_match_result_typedef<std::pmr::wstring::const_iterator, std::pmr::wsmatch>();
+#endif
   }
   {
     // Check that std::match_results has been included and is complete.
     std::pmr::smatch s;
     assert(s.get_allocator().resource() == std::pmr::get_default_resource());
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.aliases/header_string_synop2.pass.cpp

 // } // namespace std::pmr
 
 #include <string>
 
 int main(int, char**) {
   {
     // Check that std::pmr::string is usable without <memory_resource>.
     std::pmr::string s;
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::pmr::wstring ws;
+#endif
     std::pmr::u16string u16s;
     std::pmr::u32string u32s;
   }
 
   return 0;
 }