feat!: use C++20 for std::format

Author: XuehaiPan

include/optree/exceptions.h

@@ -18,8 +18,8 @@ limitations under the License.
 #pragma once
 
 #include <cstddef>          // std::size_t
+#include <format>           // std::format
 #include <source_location>  // std::source_location
-#include <sstream>          // std::ostringstream
 #include <stdexcept>        // std::logic_error
 #include <string>           // std::string, std::char_traits
 #include <string_view>      // std::string_view
@@ -48,14 +48,14 @@ class InternalError : public std::logic_error {
     explicit InternalError(
         const std::string_view &message,
         const std::source_location &source_location = std::source_location::current())
-        : std::logic_error{[&message, &source_location]() -> std::string {
-              std::ostringstream oss{};
-              oss << message << " (in function `" << source_location.function_name() << "` at file "
-                  << RelpathFromProjectRoot(source_location) << ":" << source_location.line() << ":"
-                  << source_location.column() << ")\n\n"
-                  << "Please file a bug report at https://github.com/metaopt/optree/issues.";
-              return oss.str();
-          }()} {}
+        : std::logic_error{
+              std::format("{} (in function `{}` at file {}:{}:{})\n\n"
+                          "Please file a bug report at https://github.com/metaopt/optree/issues.",
+                          message,
+                          source_location.function_name(),
+                          RelpathFromProjectRoot(source_location),
+                          source_location.line(),
+                          source_location.column())} {}
 };
 
 #define VA_FUNC2_(__0, __1, NAME, ...) NAME

include/optree/pytypes.h

@@ -18,6 +18,7 @@ limitations under the License.
 #pragma once
 
 #include <exception>      // std::rethrow_exception, std::current_exception
+#include <format>         // std::format, std::format_to, std::formatter
 #include <string>         // std::string
 #include <type_traits>    // std::is_base_of_v
 #include <unordered_map>  // std::unordered_map
@@ -49,6 +50,29 @@ inline Py_ALWAYS_INLINE std::string PyRepr(const std::string &string) {
     return static_cast<std::string>(py::repr(py::str(string)));
 }
 
+template <typename CharT>
+struct std::formatter<py::handle, CharT> {
+    template <class ParseContext>
+    constexpr ParseContext::iterator parse(const ParseContext &context) {
+        return context.begin();
+    }
+    template <class FormatContext>
+    FormatContext::iterator format(const py::handle &object, FormatContext &context) const {
+        return std::format_to(context.out(), "{}", PyRepr(object));
+    }
+};
+template <typename CharT>
+struct std::formatter<py::object, CharT> {
+    template <class ParseContext>
+    constexpr ParseContext::iterator parse(const ParseContext &context) {
+        return context.begin();
+    }
+    template <class FormatContext>
+    FormatContext::iterator format(const py::object &object, FormatContext &context) const {
+        return std::format_to(context.out(), "{}", PyRepr(object));
+    }
+};
+
 // The maximum size of the type cache.
 constexpr py::ssize_t MAX_TYPE_CACHE_SIZE = 4096;
 
@@ -173,31 +197,31 @@ inline Py_ALWAYS_INLINE void DictSetItem(const py::handle &dict,
 
 inline Py_ALWAYS_INLINE void AssertExactList(const py::handle &object) {
     if (!PyList_CheckExact(object.ptr())) [[unlikely]] {
-        throw py::value_error("Expected an instance of list, got " + PyRepr(object) + ".");
+        throw py::value_error(std::format("Expected an instance of list, got {}.", object));
     }
 }
 inline Py_ALWAYS_INLINE void AssertExactTuple(const py::handle &object) {
     if (!PyTuple_CheckExact(object.ptr())) [[unlikely]] {
-        throw py::value_error("Expected an instance of tuple, got " + PyRepr(object) + ".");
+        throw py::value_error(std::format("Expected an instance of tuple, got {}.", object));
     }
 }
 inline Py_ALWAYS_INLINE void AssertExactDict(const py::handle &object) {
     if (!PyDict_CheckExact(object.ptr())) [[unlikely]] {
-        throw py::value_error("Expected an instance of dict, got " + PyRepr(object) + ".");
+        throw py::value_error(std::format("Expected an instance of dict, got {}.", object));
     }
 }
 
 inline Py_ALWAYS_INLINE void AssertExactOrderedDict(const py::handle &object) {
     if (!py::type::handle_of(object).is(PyOrderedDictTypeObject)) [[unlikely]] {
-        throw py::value_error("Expected an instance of collections.OrderedDict, got " +
-                              PyRepr(object) + ".");
+        throw py::value_error(
+            std::format("Expected an instance of collections.OrderedDict, got {}.", object));
     }
 }
 
 inline Py_ALWAYS_INLINE void AssertExactDefaultDict(const py::handle &object) {
     if (!py::type::handle_of(object).is(PyDefaultDictTypeObject)) [[unlikely]] {
-        throw py::value_error("Expected an instance of collections.defaultdict, got " +
-                              PyRepr(object) + ".");
+        throw py::value_error(
+            std::format("Expected an instance of collections.defaultdict, got {}.", object));
     }
 }
 
@@ -206,16 +230,16 @@ inline Py_ALWAYS_INLINE void AssertExactStandardDict(const py::handle &object) {
           py::type::handle_of(object).is(PyOrderedDictTypeObject) ||
           py::type::handle_of(object).is(PyDefaultDictTypeObject))) [[unlikely]] {
         throw py::value_error(
-            "Expected an instance of dict, collections.OrderedDict, or collections.defaultdict, "
-            "got " +
-            PyRepr(object) + ".");
+            std::format("Expected an instance of dict, collections.OrderedDict, "
+                        "or collections.defaultdict, got {}.",
+                        object));
     }
 }
 
 inline Py_ALWAYS_INLINE void AssertExactDeque(const py::handle &object) {
     if (!py::type::handle_of(object).is(PyDequeTypeObject)) [[unlikely]] {
-        throw py::value_error("Expected an instance of collections.deque, got " + PyRepr(object) +
-                              ".");
+        throw py::value_error(
+            std::format("Expected an instance of collections.deque, got {}.", object));
     }
 }
 
@@ -298,23 +322,24 @@ inline Py_ALWAYS_INLINE bool IsNamedTuple(const py::handle &object) {
 }
 inline Py_ALWAYS_INLINE void AssertExactNamedTuple(const py::handle &object) {
     if (!IsNamedTupleInstance(object)) [[unlikely]] {
-        throw py::value_error("Expected an instance of collections.namedtuple, got " +
-                              PyRepr(object) + ".");
+        throw py::value_error(
+            std::format("Expected an instance of collections.namedtuple, got {}.", object));
     }
 }
 inline py::tuple NamedTupleGetFields(const py::handle &object) {
     py::handle type;
     if (PyType_Check(object.ptr())) [[unlikely]] {
         type = object;
         if (!IsNamedTupleClass(type)) [[unlikely]] {
-            throw py::type_error("Expected a collections.namedtuple type, got " + PyRepr(object) +
-                                 ".");
+            throw py::type_error(
+                std::format("Expected a collections.namedtuple type, got {}.", object));
         }
     } else [[likely]] {
         type = py::type::handle_of(object);
         if (!IsNamedTupleClass(type)) [[unlikely]] {
-            throw py::type_error("Expected an instance of collections.namedtuple type, got " +
-                                 PyRepr(object) + ".");
+            throw py::type_error(
+                std::format("Expected an instance of collections.namedtuple type, got {}.",
+                            object));
         }
     }
     return EVALUATE_WITH_LOCK_HELD(py::getattr(type, Py_Get_ID(_fields)), type);
@@ -401,8 +426,8 @@ inline Py_ALWAYS_INLINE bool IsStructSequence(const py::handle &object) {
 }
 inline Py_ALWAYS_INLINE void AssertExactStructSequence(const py::handle &object) {
     if (!IsStructSequenceInstance(object)) [[unlikely]] {
-        throw py::value_error("Expected an instance of PyStructSequence type, got " +
-                              PyRepr(object) + ".");
+        throw py::value_error(
+            std::format("Expected an instance of PyStructSequence type, got {}.", object));
     }
 }
 inline py::tuple StructSequenceGetFieldsImpl(const py::handle &type) {
@@ -439,13 +464,13 @@ inline py::tuple StructSequenceGetFields(const py::handle &object) {
     if (PyType_Check(object.ptr())) [[unlikely]] {
         type = object;
         if (!IsStructSequenceClass(type)) [[unlikely]] {
-            throw py::type_error("Expected a PyStructSequence type, got " + PyRepr(object) + ".");
+            throw py::type_error(std::format("Expected a PyStructSequence type, got {}.", object));
         }
     } else [[likely]] {
         type = py::type::handle_of(object);
         if (!IsStructSequenceClass(type)) [[unlikely]] {
-            throw py::type_error("Expected an instance of PyStructSequence type, got " +
-                                 PyRepr(object) + ".");
+            throw py::type_error(
+                std::format("Expected an instance of PyStructSequence type, got {}.", object));
         }
     }
 
@@ -496,8 +521,9 @@ inline void TotalOrderSort(py::list &list) {  // NOLINT[runtime/references]
                 const auto sort_key_fn = py::cpp_function([](const py::object &obj) -> py::tuple {
                     const py::handle cls = py::type::handle_of(obj);
                     const py::str qualname{EVALUATE_WITH_LOCK_HELD(
-                        PyStr(py::getattr(cls, Py_Get_ID(__module__))) + "." +
-                            PyStr(py::getattr(cls, Py_Get_ID(__qualname__))),
+                        std::format("{}.{}",
+                                    PyStr(py::getattr(cls, Py_Get_ID(__module__))),
+                                    PyStr(py::getattr(cls, Py_Get_ID(__qualname__)))),
                         cls)};
                     return py::make_tuple(qualname, obj);
                 });

src/optree.cpp

@@ -17,6 +17,7 @@ limitations under the License.
 
 #include "optree/optree.h"
 
+#include <format>      // std::format
 #include <functional>  // std::{not_,}equal_to, std::less{,_equal}, std::greater{,_equal}
 #include <memory>      // std::unique_ptr
 #include <optional>    // std::optional, std::nullopt
@@ -48,8 +49,8 @@ void BuildModule(py::module_ &mod) {  // NOLINT[runtime/references]
 
     GetCxxModule(mod);
 
-    mod.doc() = "Optimized PyTree Utilities. (C extension module built from " +
-                std::string(RelpathFromProjectRoot()) + ")";
+    mod.doc() = std::format("Optimized PyTree Utilities. (C extension module built from {})",
+                            RelpathFromProjectRoot());
     mod.attr("Py_TPFLAGS_BASETYPE") = py::int_(Py_TPFLAGS_BASETYPE);
 
     // NOLINTNEXTLINE[bugprone-macro-parentheses]

src/registry.cpp

@@ -15,6 +15,7 @@ limitations under the License.
 ================================================================================
 */
 
+#include <format>       // std::format
 #include <memory>       // std::make_shared
 #include <sstream>      // std::ostringstream
 #include <string>       // std::string
@@ -42,8 +43,9 @@ template <bool NoneIsLeaf>
                          registration->type = py::reinterpret_borrow<py::object>(cls);
                          EXPECT_TRUE(
                              registry.m_registrations.emplace(cls, std::move(registration)).second,
-                             "PyTree type " + PyRepr(cls) +
-                                 " is already registered in the global namespace.");
+                             std::format("PyTree type {} is already registered "
+                                         "in the global namespace.",
+                                         cls));
                          if (sm_builtins_types.emplace(cls).second) [[likely]] {
                              cls.inc_ref();
                          }
@@ -72,8 +74,8 @@ template <bool NoneIsLeaf>
                                                  const py::object &path_entry_type,
                                                  const std::string &registry_namespace) {
     if (sm_builtins_types.find(cls) != sm_builtins_types.end()) [[unlikely]] {
-        throw py::value_error("PyTree type " + PyRepr(cls) +
-                              " is a built-in type and cannot be re-registered.");
+        throw py::value_error(
+            std::format("PyTree type {} is a built-in type and cannot be re-registered.", cls));
     }
 
     PyTreeTypeRegistry * const registry = Singleton<NoneIsLeaf>();
@@ -85,55 +87,56 @@ template <bool NoneIsLeaf>
     registration->path_entry_type = py::reinterpret_borrow<py::object>(path_entry_type);
     if (registry_namespace.empty()) [[unlikely]] {
         if (!registry->m_registrations.emplace(cls, std::move(registration)).second) [[unlikely]] {
-            throw py::value_error("PyTree type " + PyRepr(cls) +
-                                  " is already registered in the global namespace.");
+            throw py::value_error(
+                std::format("PyTree type {} is already registered in the global namespace.", cls));
         }
         if (IsStructSequenceClass(cls)) [[unlikely]] {
             PyErr_WarnEx(PyExc_UserWarning,
-                         ("PyTree type " + PyRepr(cls) +
-                          " is a class of `PyStructSequence`, "
-                          "which is already registered in the global namespace. "
-                          "Override it with custom flatten/unflatten functions.")
+                         std::format("PyTree type {} is a class of `PyStructSequence`, "
+                                     "which is already registered in the global namespace. "
+                                     "Override it with custom flatten/unflatten functions.",
+                                     cls)
                              .c_str(),
                          /*stack_level=*/2);
         } else if (IsNamedTupleClass(cls)) [[unlikely]] {
             PyErr_WarnEx(PyExc_UserWarning,
-                         ("PyTree type " + PyRepr(cls) +
-                          " is a subclass of `collections.namedtuple`, "
-                          "which is already registered in the global namespace. "
-                          "Override it with custom flatten/unflatten functions.")
+                         std::format("PyTree type {} is a subclass of `collections.namedtuple`, "
+                                     "which is already registered in the global namespace. "
+                                     "Override it with custom flatten/unflatten functions.",
+                                     cls)
                              .c_str(),
                          /*stack_level=*/2);
         }
     } else [[likely]] {
         if (!registry->m_named_registrations
                  .emplace(std::make_pair(registry_namespace, cls), std::move(registration))
                  .second) [[unlikely]] {
-            std::ostringstream oss{};
-            oss << "PyTree type " << PyRepr(cls) << " is already registered in namespace "
-                << PyRepr(registry_namespace) << ".";
-            throw py::value_error(oss.str());
+            throw py::value_error(
+                std::format("PyTree type {} is already registered in namespace {}.",
+                            cls,
+                            PyRepr(registry_namespace)));
         }
         if (IsStructSequenceClass(cls)) [[unlikely]] {
-            std::ostringstream oss{};
-            oss << "PyTree type " << PyRepr(cls)
-                << " is a class of `PyStructSequence`, "
-                   "which is already registered in the global namespace. "
-                   "Override it with custom flatten/unflatten functions in namespace "
-                << PyRepr(registry_namespace) << ".";
-            PyErr_WarnEx(PyExc_UserWarning,
-                         oss.str().c_str(),
-                         /*stack_level=*/2);
+            PyErr_WarnEx(
+                PyExc_UserWarning,
+
+                std::format("PyTree type {} is a class of `PyStructSequence`, "
+                            "which is already registered in the global namespace. "
+                            "Override it with custom flatten/unflatten functions in namespace {}.",
+                            cls,
+                            PyRepr(registry_namespace))
+                    .c_str(),
+                /*stack_level=*/2);
         } else if (IsNamedTupleClass(cls)) [[unlikely]] {
-            std::ostringstream oss{};
-            oss << "PyTree type " << PyRepr(cls)
-                << " is a subclass of `collections.namedtuple`, "
-                   "which is already registered in the global namespace. "
-                   "Override it with custom flatten/unflatten functions in namespace "
-                << PyRepr(registry_namespace) << ".";
-            PyErr_WarnEx(PyExc_UserWarning,
-                         oss.str().c_str(),
-                         /*stack_level=*/2);
+            PyErr_WarnEx(
+                PyExc_UserWarning,
+                std::format("PyTree type {} is a subclass of `collections.namedtuple`, "
+                            "which is already registered in the global namespace. "
+                            "Override it with custom flatten/unflatten functions in namespace {}.",
+                            cls,
+                            PyRepr(registry_namespace))
+                    .c_str(),
+                /*stack_level=*/2);
         }
     }
 }
@@ -166,8 +169,8 @@ template <bool NoneIsLeaf>
     const py::object &cls,
     const std::string &registry_namespace) {
     if (sm_builtins_types.find(cls) != sm_builtins_types.end()) [[unlikely]] {
-        throw py::value_error("PyTree type " + PyRepr(cls) +
-                              " is a built-in type and cannot be unregistered.");
+        throw py::value_error(
+            std::format("PyTree type {} is a built-in type and cannot be unregistered.", cls));
     }
 
     PyTreeTypeRegistry * const registry = Singleton<NoneIsLeaf>();