[libc++][format] Removes optional dependency.

[Mordante]

Summary

This is not strictly required, but avoids potential circular header
dependencies when there will be an formatter specialization for
optional.

[Mordante]

CI fixes.

[ldionne]

libcxx/include/__format/format_context.h

17

IMO it would be nice to be able to keep using optional here. I am not concerned about potential circular dependency problems because we could always granularize <optional> into <__optional/optional.h> and <__optional/formatter.h>. Then here you'd include <__optional/optional.h> only.

71–75

It's surprising to provide a move constructor here if the underlying locale is not movable. Also, should we be disengaging __other?

77–85

If you retain this, you could inline __assign into operator=(__locale const&) and call operator=(__locale const&) from operator=(__locale&&). And actually you don't need to provide operator=(__locale&&) at all, since the copy-assignment will be used if you do x = std::move(y) and x only has a copy-assignment.

[EricWF]

I'm with ldionne that we should keep using optional here. The correctness seems like a very important quality that we'll be loosing some certainty in.

libcxx/include/__format/format_context.h

56

I think __locale is already a class inside namespace std. I would prefer that we use a slightly different name so it's more clear when the type is spelled elsewhere.

[Mordante]

In D150060#4347359, @EricWF wrote:

I'm with ldionne that we should keep using optional here. The correctness seems like a very important quality that we'll be loosing some certainty in.

My main concern was when we need a formatter<optional, charT>. In D150509 I tested an alternative approach as suggested by Louis, which works without creating header cycles. So when somebody writes a paper for such a formatter we don't risk possible ABI breaks.

(MSVC STL and libstdc++ don't use an optional to implement the locale.)

Since the alternative works, this patch will be abandoned.

libcxx/include/__format/format_context.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___FORMAT_FORMAT_CONTEXT_H
 #define _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 
 #include <__availability>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/format_arg.h>
 #include <__format/format_arg_store.h>
 #include <__format/format_args.h>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__memory/addressof.h>
+#include <__memory/construct_at.h>
 #include <__utility/move.h>
 #include <__variant/monostate.h>
 #include <cstddef>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#include <locale>
-#include <optional>
+#  include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _OutIt, class _CharT>
 requires output_iterator<_OutIt, const _CharT&>
 class _LIBCPP_TEMPLATE_VIS basic_format_context;
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
+
+namespace __format {
+// [format.context]/6
+// std::locale locale();
+//   Returns: The locale passed to the formatting function if the latter
+//   takes one, and std::locale() otherwise.
+//
+// This class is a helper to implement this behaviour. The call to
+// std::locale() is done once and only when needed.
+class __locale {
+public:
+  _LIBCPP_HIDE_FROM_ABI __locale() : __dummy_{'\0'}, __engaged_{false} {}
+  _LIBCPP_HIDE_FROM_ABI __locale(locale __loc) : __loc_{__loc}, __engaged_{true} {}
+
+  _LIBCPP_HIDE_FROM_ABI ~__locale() {
+    if (__engaged_)
+      __loc_.~locale();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __locale(const __locale& __other) noexcept : __dummy_{'\0'}, __engaged_(__other.__engaged_) {
+    if (__engaged_)
+      std::construct_at(std::addressof(__loc_), __other.__loc_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __locale(__locale&& __other) noexcept : __dummy_{'\0'}, __engaged_(__other.__engaged_) {
+    // Note locale is not movable.
+    if (__engaged_)
+      __loc_ = __other.__loc_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __locale& operator=(const __locale& __other) noexcept {
+    __assign(__other);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __locale& operator=(__locale&& __other) noexcept {
+    __assign(__other);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI locale __value() {
+    if (!__engaged_) {
+      std::construct_at(std::addressof(__loc_), locale());
+      __engaged_ = true;
+    }
+
+    return __loc_;
+  }
+
+private:
+  union {
+    char __dummy_;
+    locale __loc_;
+  };
+
+  bool __engaged_;
+
+  _LIBCPP_HIDE_FROM_ABI void __assign(const __locale& __other) noexcept {
+    // Note locale is not movable.
+    if (__engaged_) {
+      if (__other.__engaged_)
+        __loc_ = __other.__loc_;
+      else {
+        __loc_.~locale();
+        __engaged_ = false;
+      }
+    } else if (__other.__engaged_) {
+      std::construct_at(std::addressof(__loc_), __other.__loc_);
+      __engaged_ = true;
+    }
+    // Both not engaged do nothing.
+  }
+};
+} // namespace __format
+
 /**
  * Helper to create a basic_format_context.
  *
  * This is needed since the constructor is private.
  */
 template <class _OutIt, class _CharT>
-_LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
-__format_context_create(
-    _OutIt __out_it,
-    basic_format_args<basic_format_context<_OutIt, _CharT>> __args,
-    optional<_VSTD::locale>&& __loc = nullopt) {
-  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args, _VSTD::move(__loc));
+_LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT> __format_context_create(
+    _OutIt __out_it, basic_format_args<basic_format_context<_OutIt, _CharT>> __args, __format::__locale __loc = {}) {
+  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args, __loc);
 }
-#else
+#  else
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
   return _VSTD::basic_format_context(_VSTD::move(__out_it), __args);
 }
-#endif
+#  endif
 
 using format_context =
     basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
                          char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_context = basic_format_context<
     back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>;
 #endif
public:
   template <class _Tp>
   using formatter_type = formatter<_Tp, _CharT>;
 
   _LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context>
   arg(size_t __id) const noexcept {
     return __args_.get(__id);
   }
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-  _LIBCPP_HIDE_FROM_ABI _VSTD::locale locale() {
-    if (!__loc_)
-      __loc_ = _VSTD::locale{};
-    return *__loc_;
-  }
-#endif
+  _LIBCPP_HIDE_FROM_ABI _VSTD::locale locale() { return __loc_.__value(); }
+#  endif
   _LIBCPP_HIDE_FROM_ABI iterator out() { return std::move(__out_it_); }
   _LIBCPP_HIDE_FROM_ABI void advance_to(iterator __it) { __out_it_ = std::move(__it); }
 
 private:
   iterator __out_it_;
   basic_format_args<basic_format_context> __args_;
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
-  // The Standard doesn't specify how the locale is stored.
-  // [format.context]/6
-  // std::locale locale();
-  //   Returns: The locale passed to the formatting function if the latter
-  //   takes one, and std::locale() otherwise.
-  // This is done by storing the locale of the constructor in this optional. If
-  // locale() is called and the optional has no value the value will be created.
-  // This allows the implementation to lazily create the locale.
-  // TODO FMT Validate whether lazy creation is the best solution.
-  optional<_VSTD::locale> __loc_;
+  __format::__locale __loc_;
 
   template <class __OutIt, class __CharT>
   friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
-  __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>,
-                          optional<_VSTD::locale>&&);
+  __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>, __format::__locale __loc);
 
   // Note: the Standard doesn't specify the required constructors.
-  _LIBCPP_HIDE_FROM_ABI
-  explicit basic_format_context(_OutIt __out_it,
-                                basic_format_args<basic_format_context> __args,
-                                optional<_VSTD::locale>&& __loc)
-      : __out_it_(_VSTD::move(__out_it)), __args_(__args),
-        __loc_(_VSTD::move(__loc)) {}
-#else
+  _LIBCPP_HIDE_FROM_ABI explicit basic_format_context(
+      _OutIt __out_it, basic_format_args<basic_format_context> __args, __format::__locale __loc)
+      : __out_it_(_VSTD::move(__out_it)), __args_(__args), __loc_(__loc) {}
+#  else
   template <class __OutIt, class __CharT>
   friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
       __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>);
 
   _LIBCPP_HIDE_FROM_ABI
   explicit basic_format_context(_OutIt __out_it,
                                 basic_format_args<basic_format_context> __args)
       : __out_it_(_VSTD::move(__out_it)), __args_(__args) {}
-#endif
+#  endif
 };
 
 // A specialization for __retarget_buffer
 //
 // See __retarget_buffer for the motivation for this specialization.
 //
 // This context holds a reference to the instance of the basic_format_context
 // that is retargeted. It converts a formatting argument when it is requested

libcxx/include/module.modulemap.in

module __format {
       module enable_insertable               { private header "__format/enable_insertable.h" }
       module escaped_output_table            { private header "__format/escaped_output_table.h" }
       module extended_grapheme_cluster_table { private header "__format/extended_grapheme_cluster_table.h" }
       module format_arg                      { private header "__format/format_arg.h" }
       module format_arg_store                { private header "__format/format_arg_store.h" }
       module format_args                     { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
-        export optional
         export locale
         export __locale
       }
       module format_error                    { private header "__format/format_error.h" }
       module format_functions                {
         private header "__format/format_functions.h"
         export string
       }

libcxx/test/libcxx/transitive_includes/cxx03.csv

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list algorithm

libcxx/test/libcxx/transitive_includes/cxx11.csv

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list algorithm

libcxx/test/libcxx/transitive_includes/cxx14.csv

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list algorithm

libcxx/test/libcxx/transitive_includes/cxx17.csv

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list algorithm

libcxx/test/libcxx/transitive_includes/cxx20.csv

 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring
 chrono ctime
 chrono limits
 chrono locale
-chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view
 chrono tuple
 chrono type_traits

 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list algorithm

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono ctime
 chrono initializer_list
 chrono limits
 chrono locale
 chrono new
-chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view
 chrono tuple
 chrono version

 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits
 format locale
 format new
-format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version
 forward_list compare