From c208e918e55c423203692343b56d893dc7435095 Mon Sep 17 00:00:00 2001
From: eldritch horrors <pennae@lix.systems>
Date: Mon, 4 Mar 2024 06:08:39 +0100
Subject: [PATCH] fix: `nlohmann::adl_serializer` for `std::optional` (#9147)

This allows templates such as `NLOHMANN_DEFINE_TYPE_*` templates and other generators with things like `std::vector<std::optional<T>>`.

Co-authored-by: John Ericson <John.Ericson@Obsidian.Systems>
(cherry picked from commit 02bd821f2e71372d31bbe6700bd68086cc2ee70a)
Change-Id: I8b0ebcf2af4226610dadd565962f2d2327415a03
---
 src/libutil/json-utils.hh        | 19 ++++++++---
 tests/unit/libutil/json-utils.cc | 58 ++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 5 deletions(-)
 create mode 100644 tests/unit/libutil/json-utils.cc

diff --git a/src/libutil/json-utils.hh b/src/libutil/json-utils.hh
index 77c63595c..06dd80cf7 100644
--- a/src/libutil/json-utils.hh
+++ b/src/libutil/json-utils.hh
@@ -78,20 +78,29 @@ namespace nlohmann {
  */
 template<typename T>
 struct adl_serializer<std::optional<T>> {
-    static std::optional<T> from_json(const json & json) {
+    /**
+     * @brief Convert a JSON type to an `optional<T>` treating
+     *        `null` as `std::nullopt`.
+     */
+    static void from_json(const json & json, std::optional<T> & t) {
         static_assert(
             nix::json_avoids_null<T>::value,
             "null is already in use for underlying type's JSON");
-        return json.is_null()
+        t = json.is_null()
             ? std::nullopt
-            : std::optional { adl_serializer<T>::from_json(json) };
+            : std::make_optional(json.template get<T>());
     }
-    static void to_json(json & json, std::optional<T> t) {
+
+    /**
+     *  @brief Convert an optional type to a JSON type  treating `std::nullopt`
+     *         as `null`.
+     */
+    static void to_json(json & json, const std::optional<T> & t) {
         static_assert(
             nix::json_avoids_null<T>::value,
             "null is already in use for underlying type's JSON");
         if (t)
-            adl_serializer<T>::to_json(json, *t);
+            json = *t;
         else
             json = nullptr;
     }
diff --git a/tests/unit/libutil/json-utils.cc b/tests/unit/libutil/json-utils.cc
new file mode 100644
index 000000000..f0ce15c93
--- /dev/null
+++ b/tests/unit/libutil/json-utils.cc
@@ -0,0 +1,58 @@
+#include <vector>
+#include <optional>
+
+#include <gtest/gtest.h>
+
+#include "json-utils.hh"
+
+namespace nix {
+
+/* Test `to_json` and `from_json` with `std::optional` types.
+ * We are specifically interested in whether we can _nest_ optionals in STL
+ * containers so we that we can leverage existing adl_serializer templates. */
+
+TEST(to_json, optionalInt) {
+    std::optional<int> val = std::make_optional(420);
+    ASSERT_EQ(nlohmann::json(val), nlohmann::json(420));
+    val = std::nullopt;
+    ASSERT_EQ(nlohmann::json(val), nlohmann::json(nullptr));
+}
+
+TEST(to_json, vectorOfOptionalInts) {
+    std::vector<std::optional<int>> vals = {
+        std::make_optional(420),
+        std::nullopt,
+    };
+    ASSERT_EQ(nlohmann::json(vals), nlohmann::json::parse("[420,null]"));
+}
+
+TEST(to_json, optionalVectorOfInts) {
+    std::optional<std::vector<int>> val = std::make_optional(std::vector<int> {
+        -420,
+        420,
+    });
+    ASSERT_EQ(nlohmann::json(val), nlohmann::json::parse("[-420,420]"));
+    val = std::nullopt;
+    ASSERT_EQ(nlohmann::json(val), nlohmann::json(nullptr));
+}
+
+TEST(from_json, optionalInt) {
+    nlohmann::json json = 420;
+    std::optional<int> val = json;
+    ASSERT_TRUE(val.has_value());
+    ASSERT_EQ(*val, 420);
+    json = nullptr;
+    json.get_to(val);
+    ASSERT_FALSE(val.has_value());
+}
+
+TEST(from_json, vectorOfOptionalInts) {
+    nlohmann::json json = { 420, nullptr };
+    std::vector<std::optional<int>> vals = json;
+    ASSERT_EQ(vals.size(), 2);
+    ASSERT_TRUE(vals.at(0).has_value());
+    ASSERT_EQ(*vals.at(0), 420);
+    ASSERT_FALSE(vals.at(1).has_value());
+}
+
+} /* namespace nix */