Document and test the lifetime of string_view members decoded from a json_view

A struct with a std::string_view member defined via NLOHMANN_DEFINE_TYPE_*
decodes from a json_view without a copy: the member points into the source
text, or, for a string with escape sequences, into the buffer of decoded
strings of the document. It is valid while the document is alive and, for a
document that borrows its text, while that text is.

The feature page now says so, including that the same struct compiles with
json::parse(text).get<T>() and then points into the temporary json value.
The new test checks where plain and escaped members point and that they stay
readable while the document and a borrowed source text are alive. It does not
read dangling memory.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

docs/mkdocs/docs/api/basic_json_document/accept.md

@@ -13,15 +13,9 @@ function never throws an exception for invalid input, and the returned `#!cpp bo
 is returned.
 
 The result is the same as that of `BasicJsonType::accept()` by design; the difference is how the check is made. This
-function runs the document's builder, which checks the text as [`parse()`](parse.md) does, while
-`BasicJsonType::accept()` runs the SAX parser with a handler that ignores every event. Use this one if you go on to
-parse the same input with [`parse()`](parse.md) anyway, so that both use the same code; either is fine for a plain
-yes/no answer.
-
-When both `ignore_comments` and `ignore_trailing_commas` are `#!cpp false` (the default), the builder writes no index.
-With either option set, it builds the index as [`parse()`](parse.md) does and discards it: the result is the same, only
-the time differs. (Neither option needs the index; the variant that skips it exists only for the default options to
-keep the code size down.)
+function runs the document's index builder (and discards the index), while `BasicJsonType::accept()` runs the SAX
+parser with a handler that ignores every event. Use this one if you go on to parse the same input with
+[`parse()`](parse.md) anyway, so that both use the same code; either is fine for a plain yes/no answer.
 
 ## Template parameters
 

docs/mkdocs/docs/features/json_view.md

@@ -253,6 +253,34 @@ Two conversions never copy at all:
 
 Both results are only valid as long as the view — and, for a string with no escapes, the borrowed source text — is.
 
+### `string_view` members
+
+A struct whose member is a `#!cpp std::string_view` (C++17) can be decoded from a view with the
+`NLOHMANN_DEFINE_TYPE_*` macros, and the member is not copied either: for a string without escape sequences it points
+into the document's source text, and for a string with escape sequences into the document's buffer of decoded strings.
+The member is valid as long as the document is alive and, for a document that
+[borrows its source text](#ownership-and-lifetime) (as [`parse()`](../api/basic_json_document/parse.md) does for
+an lvalue `#!cpp std::string`, a `#!cpp std::string_view`, or a C string), as long as that text is.
+
+```cpp
+struct record
+{
+    std::string_view name;
+    int count;
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(record, name, count)
+};
+
+const std::string text = R"({"name": "widget", "count": 3})";
+const json_document doc = json_document::parse(text);  // borrows text
+const record r = doc.root().get<record>();             // r.name points into text, valid while text and doc are
+```
+
+!!! warning "Decoding into a `string_view` from a `json` value dangles at once"
+
+    The same struct also compiles with `#!cpp json::parse(text).get<record>()`, but there `name` points into the
+    temporary `json` value, which is destroyed at the end of the statement. Use a named
+    [`json_document`](../api/json_document.md), as above, to decode such a struct.
+
 ## Writing generic code
 
 A view's type names its `BasicJsonType` and its [`view_mode`](../api/view_mode.md):

include/nlohmann/detail/view/builder.hpp

@@ -16,7 +16,6 @@
 #include <cstring> // memcmp, memcpy
 #include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // false_type, integral_constant, true_type
 #include <vector> // vector
 
 #include <nlohmann/json.hpp>
@@ -70,8 +69,7 @@ struct parse_failure
 };
 
 /// FloatType: the number_float_t of the document, whose overflow parse() rejects
-/// Store: false for accept(): the grammar, number, string and UTF-8 checks run as for parse(), but no node is written
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel>
 class builder
 {
   public:
@@ -247,88 +245,6 @@ class builder
         return p;
     }
 
-    /// the string from p, the first backslash, control character, ill-formed UTF-8 byte, or the end, checked and not
-    /// decoded (accept() stores nothing, so the arena is not written): the checks, errors and error positions of
-    /// slow_string(), for everything up to the closing quote
-    NLOHMANN_VIEW_NOINLINE decoded check_string(const unsigned char* p)
-    {
-        const unsigned char* const end = m_end;
-        for (;;)
-        {
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char c = *p;
-            if (c == '"')
-            {
-                ++p;
-                return decoded{p, 0, 0};
-            }
-            if (c != '\\')
-            {
-                return failed(c < 0x20 ? error_code::string_control_character : error_code::string_utf8, p);
-            }
-            ++p;
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char d = *p++;
-            if (d == 'u')
-            {
-                const int cp = hex4(p); // (moves p past the four digits)
-                if (NLOHMANN_VIEW_UNLIKELY(cp < 0))
-                {
-                    return failed(error_code::string_unicode_hex, p);
-                }
-                if (NLOHMANN_VIEW_UNLIKELY((cp & 0xF800) == 0xD800)) // a surrogate
-                {
-                    if (cp >= 0xDC00)
-                    {
-                        return failed(error_code::string_surrogate_low, p);
-                    }
-                    if (end - p < 2 || p[0] != '\\' || p[1] != 'u')
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                    p += 2;
-                    const int lo = hex4(p); // (moves p past the four digits)
-                    if (lo < 0)
-                    {
-                        return failed(error_code::string_unicode_hex, p);
-                    }
-                    if (lo < 0xDC00 || lo > 0xDFFF)
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                }
-            }
-            else if (!(d == '"' || d == '\\' || d == '/' || d == 'b' || d == 'f' || d == 'n' || d == 'r' || d == 't'))
-            {
-                --p;
-                return failed(error_code::string_escape, p);
-            }
-            p = scan_string_run(p, end); // the text up to the next backslash, quote, control character, or ill-formed UTF-8
-        }
-    }
-
-    /// the string from p, decoded into the arena, or only checked (Store == false)
-    decoded decode_string(const unsigned char* s, const unsigned char* p)
-    {
-        return decode_string(s, p, std::integral_constant<bool, Store>());
-    }
-
-    decoded decode_string(const unsigned char* s, const unsigned char* p, std::true_type /*unused*/)
-    {
-        return slow_string(s, p);
-    }
-
-    decoded decode_string(const unsigned char* /*unused*/, const unsigned char* p, std::false_type /*unused*/)
-    {
-        return check_string(p);
-    }
-
     /// s points to the start of the string, p to a backslash, a control
     /// character, an ill-formed UTF-8 byte, or the end: decode the string into
     /// the arena
@@ -694,13 +610,10 @@ run_found:
 
         NLOHMANN_VIEW_ALWAYS_INLINE bool run()
         {
-            if (enabled(Store))
-            {
-                cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
-                base = cold.m_doc.nodes;
-                out = base;
-                cap = base + cold.m_doc.node_capacity;
-            }
+            cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
+            base = cold.m_doc.nodes;
+            out = base;
+            cap = base + cold.m_doc.node_capacity;
 
             if (e - p >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF)
             {
@@ -884,10 +797,7 @@ close_object:
             // an array pays nothing for this)
             if (NLOHMANN_VIEW_UNLIKELY(cur_count >= document_data::index_min_members))
             {
-                if (enabled(Store))
-                {
-                    cold.note_large_object(cur_idx);
-                }
+                cold.note_large_object(cur_idx);
             }
 
 close_container:
@@ -1047,12 +957,6 @@ indent_done:
         /// an integer's value); two stores on little-endian targets
         NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(node_kind k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
-            if (!enabled(Store))
-            {
-                // accept(): nothing is stored, so what computes the arguments is not run either. base and out stay
-                // null: their difference, which open() takes, is 0.
-                return out;
-            }
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
                 const auto n = static_cast<std::size_t>(out - base);
@@ -1111,12 +1015,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void close()
         {
-            if (enabled(Store))
-            {
-                node& n = base[cur_idx];
-                n.len = cur_count;
-                n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
-            }
+            node& n = base[cur_idx];
+            n.len = cur_count;
+            n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
             if (--depth != 0)
             {
                 if (NLOHMANN_VIEW_LIKELY(depth <= 64))
@@ -1271,7 +1172,7 @@ indent_done:
                 ++p;
                 return true;
             }
-            const decoded r = cold.decode_string(s, p);
+            const decoded r = cold.slow_string(s, p);
             if (r.p == nullptr)
             {
                 return false;
@@ -1291,44 +1192,34 @@ indent_done:
 };
 
 /// run the builder with compile-time options
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd>
 inline bool build_with(document_data& d, const char* src, std::size_t size, bool sentinel, parse_failure& failure)
 {
     if (sentinel)
     {
-        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true, Store> bld(d, src, size);
+        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true> bld(d, src, size);
         const bool ok = bld.run();
         failure = bld.failure();
         return ok;
     }
-    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false, Store> bld(d, src, size);
+    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false> bld(d, src, size);
     const bool ok = bld.run();
     failure = bld.failure();
     return ok;
 }
 
 /// sentinel: src[size] is readable and 0 (e.g. std::string); FloatType: the
-/// number_float_t of the document; validate_only: accept(), only the result is
-/// used
+/// number_float_t of the document
 template<typename FloatType, bool NulIsEnd>
-inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, bool validate_only,
-                  parse_failure& failure)
+inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, parse_failure& failure)
 {
-    if (validate_only && !comments && !trailing_commas)
-    {
-        // accept() of plain JSON: nothing is stored. The other option sets
-        // could skip the stores just as well; they keep the builder that
-        // stores only so that there are two more instantiations of the parse
-        // loop, not eight.
-        return build_with<FloatType, false, false, NulIsEnd, false>(d, src, size, sentinel, failure);
-    }
     if (comments)
     {
-        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-               : build_with<FloatType, true, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd>(d, src, size, sentinel, failure)
+               : build_with<FloatType, true, false, NulIsEnd>(d, src, size, sentinel, failure);
     }
-    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-           : build_with<FloatType, false, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd>(d, src, size, sentinel, failure)
+           : build_with<FloatType, false, false, NulIsEnd>(d, src, size, sentinel, failure);
 }
 
 }  // namespace view

include/nlohmann/json_view.hpp

@@ -1060,7 +1060,7 @@ class basic_json_document
                                      const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_range(first, last, error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.read_range(first, last, allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -1075,7 +1075,7 @@ class basic_json_document
         basic_json_document d;
         std::string buf;
         append_input(buf, std::forward<InputType>(input));
-        d.build_owned(std::move(buf), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.build_owned(std::move(buf), allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -1088,8 +1088,7 @@ class basic_json_document
     static bool accept(InputType&& input, const bool ignore_comments = false, const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_kind(std::forward<InputType>(input), on_error::validate, ignore_comments, ignore_trailing_commas,
-                    std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
+        d.read(std::forward<InputType>(input), false, ignore_comments, ignore_trailing_commas);
         return !d.is_discarded();
     }
 
@@ -1105,7 +1104,7 @@ class basic_json_document
               const bool ignore_comments = false,
               const bool ignore_trailing_commas = false)
     {
-        read_kind(std::forward<InputType>(input), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas,
+        read_kind(std::forward<InputType>(input), allow_exceptions, ignore_comments, ignore_trailing_commas,
                   std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
     }
 
@@ -1464,22 +1463,6 @@ class basic_json_document
         return idx;
     }
 
-    /// what a failed parse does
-    enum class on_error : std::uint8_t
-    {
-        discard, ///< the document is discarded
-        raise,   ///< parse_error is thrown
-        validate ///< accept(): the document is discarded, and no node is stored while parsing
-    };
-
-    static on_error error_mode(bool allow_exceptions) noexcept
-    {
-        return allow_exceptions ? on_error::raise : on_error::discard;
-    }
-
-    /// NulIsEnd of the builder: a null byte ends the input unless strict_nul_handling
-    static constexpr bool nul_is_end = !detail::abi_config::strict_nul_handling;
-
     /// create the storage (sized for the input) on first use
     void ensure_data(const char* src, std::size_t size)
     {
@@ -1491,7 +1474,7 @@ class basic_json_document
 
     /// parse a buffer the document takes ownership of (it replaces the
     /// previous owned copy)
-    void build_owned(std::string&& buf, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_owned(std::string&& buf, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         ensure_data(buf.data(), buf.size());
         m_data->owned = std::move(buf);
@@ -1501,7 +1484,7 @@ class basic_json_document
     /// parse a copy of the input; the copy is appended to the cleared owned
     /// buffer, so that its capacity is reused
     template<typename T>
-    void build_copy(T&& input, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_copy(T&& input, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         if (!m_data)
         {
@@ -1522,7 +1505,7 @@ class basic_json_document
     }
 
     /// sentinel: src[size] is readable and 0 (std::string, C strings)
-    void build(const char* src, std::size_t size, on_error allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
+    void build(const char* src, std::size_t size, bool allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
     {
         ensure_data(src, size);
         document_data& d = *m_data;
@@ -1549,8 +1532,7 @@ class basic_json_document
         }
         else
         {
-            ok = detail::view::build<typename BasicJsonType::number_float_t, nul_is_end>(d, src, size, comments, trailing_commas, sentinel,
-                 allow_exceptions == on_error::validate, failure);
+            ok = detail::view::build < typename BasicJsonType::number_float_t, !detail::abi_config::strict_nul_handling > (d, src, size, comments, trailing_commas, sentinel, failure);
         }
         if (NLOHMANN_VIEW_LIKELY(ok))
         {
@@ -1563,7 +1545,7 @@ class basic_json_document
             return;
         }
         std::vector<std::uint32_t>().swap(d.large_objects);
-        if (allow_exceptions == on_error::raise)
+        if (allow_exceptions)
         {
             detail::view::throw_parse_failure<BasicJsonType>(failure, src, size, comments, trailing_commas);
         }
@@ -1571,13 +1553,13 @@ class basic_json_document
 
     // --- input dispatch (see detail::view::input_kind) ---
 
-    void read_kind(std::string&& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
+    void read_kind(std::string&& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
     {
         build_owned(std::move(s), ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -1591,7 +1573,7 @@ class basic_json_document
     }
 
     template<typename Array>
-    void read_kind(Array& a, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
+    void read_kind(Array& a, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
     {
         using CharT = typename std::remove_cv<typename std::remove_extent<Array>::type>::type;
         const std::size_t n = std::extent<Array>::value;
@@ -1602,7 +1584,7 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
     {
         // std::basic_string guarantees data()[size()] == 0: use it as sentinel
         const auto size = static_cast<std::size_t>(s.size());
@@ -1611,13 +1593,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
     {
         build_copy(s, ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -1629,13 +1611,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(T&& input, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
+    void read_kind(T&& input, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
     {
         build_copy(std::forward<T>(input), ae, c, tc);
     }
 
     template<typename IteratorType>
-    void read_range(IteratorType first, IteratorType last, on_error ae, bool c, bool tc)
+    void read_range(IteratorType first, IteratorType last, bool ae, bool c, bool tc)
     {
         using value_type = typename std::remove_cv<typename std::iterator_traits<IteratorType>::value_type>::type;
         // borrow the range where the library's input adapter scans it as one
@@ -1646,14 +1628,14 @@ class basic_json_document
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
     {
         const auto size = static_cast<std::size_t>(std::distance(first, last));
         build(size == 0 ? "" : reinterpret_cast<const char*>(&*first), size, ae, c, tc, false, size == 0); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::false_type /*other*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::false_type /*other*/)
     {
         build_copy(detail::view::make_adapter_input(detail::input_adapter(first, last)), ae, c, tc);
     }

single_include/nlohmann/json_view.hpp

@@ -88,7 +88,6 @@
 #include <cstring> // memcmp, memcpy
 #include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // false_type, integral_constant, true_type
 #include <vector> // vector
 
 // #include <nlohmann/json.hpp>
@@ -1312,8 +1311,7 @@ struct parse_failure
 };
 
 /// FloatType: the number_float_t of the document, whose overflow parse() rejects
-/// Store: false for accept(): the grammar, number, string and UTF-8 checks run as for parse(), but no node is written
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel>
 class builder
 {
   public:
@@ -1489,88 +1487,6 @@ class builder
         return p;
     }
 
-    /// the string from p, the first backslash, control character, ill-formed UTF-8 byte, or the end, checked and not
-    /// decoded (accept() stores nothing, so the arena is not written): the checks, errors and error positions of
-    /// slow_string(), for everything up to the closing quote
-    NLOHMANN_VIEW_NOINLINE decoded check_string(const unsigned char* p)
-    {
-        const unsigned char* const end = m_end;
-        for (;;)
-        {
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char c = *p;
-            if (c == '"')
-            {
-                ++p;
-                return decoded{p, 0, 0};
-            }
-            if (c != '\\')
-            {
-                return failed(c < 0x20 ? error_code::string_control_character : error_code::string_utf8, p);
-            }
-            ++p;
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char d = *p++;
-            if (d == 'u')
-            {
-                const int cp = hex4(p); // (moves p past the four digits)
-                if (NLOHMANN_VIEW_UNLIKELY(cp < 0))
-                {
-                    return failed(error_code::string_unicode_hex, p);
-                }
-                if (NLOHMANN_VIEW_UNLIKELY((cp & 0xF800) == 0xD800)) // a surrogate
-                {
-                    if (cp >= 0xDC00)
-                    {
-                        return failed(error_code::string_surrogate_low, p);
-                    }
-                    if (end - p < 2 || p[0] != '\\' || p[1] != 'u')
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                    p += 2;
-                    const int lo = hex4(p); // (moves p past the four digits)
-                    if (lo < 0)
-                    {
-                        return failed(error_code::string_unicode_hex, p);
-                    }
-                    if (lo < 0xDC00 || lo > 0xDFFF)
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                }
-            }
-            else if (!(d == '"' || d == '\\' || d == '/' || d == 'b' || d == 'f' || d == 'n' || d == 'r' || d == 't'))
-            {
-                --p;
-                return failed(error_code::string_escape, p);
-            }
-            p = scan_string_run(p, end); // the text up to the next backslash, quote, control character, or ill-formed UTF-8
-        }
-    }
-
-    /// the string from p, decoded into the arena, or only checked (Store == false)
-    decoded decode_string(const unsigned char* s, const unsigned char* p)
-    {
-        return decode_string(s, p, std::integral_constant<bool, Store>());
-    }
-
-    decoded decode_string(const unsigned char* s, const unsigned char* p, std::true_type /*unused*/)
-    {
-        return slow_string(s, p);
-    }
-
-    decoded decode_string(const unsigned char* /*unused*/, const unsigned char* p, std::false_type /*unused*/)
-    {
-        return check_string(p);
-    }
-
     /// s points to the start of the string, p to a backslash, a control
     /// character, an ill-formed UTF-8 byte, or the end: decode the string into
     /// the arena
@@ -1936,13 +1852,10 @@ run_found:
 
         NLOHMANN_VIEW_ALWAYS_INLINE bool run()
         {
-            if (enabled(Store))
-            {
-                cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
-                base = cold.m_doc.nodes;
-                out = base;
-                cap = base + cold.m_doc.node_capacity;
-            }
+            cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
+            base = cold.m_doc.nodes;
+            out = base;
+            cap = base + cold.m_doc.node_capacity;
 
             if (e - p >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF)
             {
@@ -2126,10 +2039,7 @@ close_object:
             // an array pays nothing for this)
             if (NLOHMANN_VIEW_UNLIKELY(cur_count >= document_data::index_min_members))
             {
-                if (enabled(Store))
-                {
-                    cold.note_large_object(cur_idx);
-                }
+                cold.note_large_object(cur_idx);
             }
 
 close_container:
@@ -2289,12 +2199,6 @@ indent_done:
         /// an integer's value); two stores on little-endian targets
         NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(node_kind k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
-            if (!enabled(Store))
-            {
-                // accept(): nothing is stored, so what computes the arguments is not run either. base and out stay
-                // null: their difference, which open() takes, is 0.
-                return out;
-            }
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
                 const auto n = static_cast<std::size_t>(out - base);
@@ -2353,12 +2257,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void close()
         {
-            if (enabled(Store))
-            {
-                node& n = base[cur_idx];
-                n.len = cur_count;
-                n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
-            }
+            node& n = base[cur_idx];
+            n.len = cur_count;
+            n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
             if (--depth != 0)
             {
                 if (NLOHMANN_VIEW_LIKELY(depth <= 64))
@@ -2513,7 +2414,7 @@ indent_done:
                 ++p;
                 return true;
             }
-            const decoded r = cold.decode_string(s, p);
+            const decoded r = cold.slow_string(s, p);
             if (r.p == nullptr)
             {
                 return false;
@@ -2533,44 +2434,34 @@ indent_done:
 };
 
 /// run the builder with compile-time options
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd>
 inline bool build_with(document_data& d, const char* src, std::size_t size, bool sentinel, parse_failure& failure)
 {
     if (sentinel)
     {
-        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true, Store> bld(d, src, size);
+        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true> bld(d, src, size);
         const bool ok = bld.run();
         failure = bld.failure();
         return ok;
     }
-    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false, Store> bld(d, src, size);
+    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false> bld(d, src, size);
     const bool ok = bld.run();
     failure = bld.failure();
     return ok;
 }
 
 /// sentinel: src[size] is readable and 0 (e.g. std::string); FloatType: the
-/// number_float_t of the document; validate_only: accept(), only the result is
-/// used
+/// number_float_t of the document
 template<typename FloatType, bool NulIsEnd>
-inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, bool validate_only,
-                  parse_failure& failure)
+inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, parse_failure& failure)
 {
-    if (validate_only && !comments && !trailing_commas)
-    {
-        // accept() of plain JSON: nothing is stored. The other option sets
-        // could skip the stores just as well; they keep the builder that
-        // stores only so that there are two more instantiations of the parse
-        // loop, not eight.
-        return build_with<FloatType, false, false, NulIsEnd, false>(d, src, size, sentinel, failure);
-    }
     if (comments)
     {
-        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-               : build_with<FloatType, true, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd>(d, src, size, sentinel, failure)
+               : build_with<FloatType, true, false, NulIsEnd>(d, src, size, sentinel, failure);
     }
-    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-           : build_with<FloatType, false, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd>(d, src, size, sentinel, failure)
+           : build_with<FloatType, false, false, NulIsEnd>(d, src, size, sentinel, failure);
 }
 
 }  // namespace view
@@ -10210,7 +10101,7 @@ class basic_json_document
                                      const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_range(first, last, error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.read_range(first, last, allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -10225,7 +10116,7 @@ class basic_json_document
         basic_json_document d;
         std::string buf;
         append_input(buf, std::forward<InputType>(input));
-        d.build_owned(std::move(buf), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.build_owned(std::move(buf), allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -10238,8 +10129,7 @@ class basic_json_document
     static bool accept(InputType&& input, const bool ignore_comments = false, const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_kind(std::forward<InputType>(input), on_error::validate, ignore_comments, ignore_trailing_commas,
-                    std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
+        d.read(std::forward<InputType>(input), false, ignore_comments, ignore_trailing_commas);
         return !d.is_discarded();
     }
 
@@ -10255,7 +10145,7 @@ class basic_json_document
               const bool ignore_comments = false,
               const bool ignore_trailing_commas = false)
     {
-        read_kind(std::forward<InputType>(input), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas,
+        read_kind(std::forward<InputType>(input), allow_exceptions, ignore_comments, ignore_trailing_commas,
                   std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
     }
 
@@ -10614,22 +10504,6 @@ class basic_json_document
         return idx;
     }
 
-    /// what a failed parse does
-    enum class on_error : std::uint8_t
-    {
-        discard, ///< the document is discarded
-        raise,   ///< parse_error is thrown
-        validate ///< accept(): the document is discarded, and no node is stored while parsing
-    };
-
-    static on_error error_mode(bool allow_exceptions) noexcept
-    {
-        return allow_exceptions ? on_error::raise : on_error::discard;
-    }
-
-    /// NulIsEnd of the builder: a null byte ends the input unless strict_nul_handling
-    static constexpr bool nul_is_end = !detail::abi_config::strict_nul_handling;
-
     /// create the storage (sized for the input) on first use
     void ensure_data(const char* src, std::size_t size)
     {
@@ -10641,7 +10515,7 @@ class basic_json_document
 
     /// parse a buffer the document takes ownership of (it replaces the
     /// previous owned copy)
-    void build_owned(std::string&& buf, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_owned(std::string&& buf, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         ensure_data(buf.data(), buf.size());
         m_data->owned = std::move(buf);
@@ -10651,7 +10525,7 @@ class basic_json_document
     /// parse a copy of the input; the copy is appended to the cleared owned
     /// buffer, so that its capacity is reused
     template<typename T>
-    void build_copy(T&& input, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_copy(T&& input, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         if (!m_data)
         {
@@ -10672,7 +10546,7 @@ class basic_json_document
     }
 
     /// sentinel: src[size] is readable and 0 (std::string, C strings)
-    void build(const char* src, std::size_t size, on_error allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
+    void build(const char* src, std::size_t size, bool allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
     {
         ensure_data(src, size);
         document_data& d = *m_data;
@@ -10699,8 +10573,7 @@ class basic_json_document
         }
         else
         {
-            ok = detail::view::build<typename BasicJsonType::number_float_t, nul_is_end>(d, src, size, comments, trailing_commas, sentinel,
-                 allow_exceptions == on_error::validate, failure);
+            ok = detail::view::build < typename BasicJsonType::number_float_t, !detail::abi_config::strict_nul_handling > (d, src, size, comments, trailing_commas, sentinel, failure);
         }
         if (NLOHMANN_VIEW_LIKELY(ok))
         {
@@ -10713,7 +10586,7 @@ class basic_json_document
             return;
         }
         std::vector<std::uint32_t>().swap(d.large_objects);
-        if (allow_exceptions == on_error::raise)
+        if (allow_exceptions)
         {
             detail::view::throw_parse_failure<BasicJsonType>(failure, src, size, comments, trailing_commas);
         }
@@ -10721,13 +10594,13 @@ class basic_json_document
 
     // --- input dispatch (see detail::view::input_kind) ---
 
-    void read_kind(std::string&& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
+    void read_kind(std::string&& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
     {
         build_owned(std::move(s), ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -10741,7 +10614,7 @@ class basic_json_document
     }
 
     template<typename Array>
-    void read_kind(Array& a, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
+    void read_kind(Array& a, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
     {
         using CharT = typename std::remove_cv<typename std::remove_extent<Array>::type>::type;
         const std::size_t n = std::extent<Array>::value;
@@ -10752,7 +10625,7 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
     {
         // std::basic_string guarantees data()[size()] == 0: use it as sentinel
         const auto size = static_cast<std::size_t>(s.size());
@@ -10761,13 +10634,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
     {
         build_copy(s, ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -10779,13 +10652,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(T&& input, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
+    void read_kind(T&& input, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
     {
         build_copy(std::forward<T>(input), ae, c, tc);
     }
 
     template<typename IteratorType>
-    void read_range(IteratorType first, IteratorType last, on_error ae, bool c, bool tc)
+    void read_range(IteratorType first, IteratorType last, bool ae, bool c, bool tc)
     {
         using value_type = typename std::remove_cv<typename std::iterator_traits<IteratorType>::value_type>::type;
         // borrow the range where the library's input adapter scans it as one
@@ -10796,14 +10669,14 @@ class basic_json_document
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
     {
         const auto size = static_cast<std::size_t>(std::distance(first, last));
         build(size == 0 ? "" : reinterpret_cast<const char*>(&*first), size, ae, c, tc, false, size == 0); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::false_type /*other*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::false_type /*other*/)
     {
         build_copy(detail::view::make_adapter_input(detail::input_adapter(first, last)), ae, c, tc);
     }

tests/src/unit-json_view_builder.cpp

@@ -59,7 +59,7 @@ built build(const std::string& text, bool comments, bool trailing_commas, bool s
         r.copy.assign(text.begin(), text.end());
         src = r.copy.data();
     }
-    r.ok = nlohmann::detail::view::build < FloatType, !nlohmann::detail::abi_config::strict_nul_handling > (*r.data, src, text.size(), comments, trailing_commas, sentinel, false, r.failure);
+    r.ok = nlohmann::detail::view::build < FloatType, !nlohmann::detail::abi_config::strict_nul_handling > (*r.data, src, text.size(), comments, trailing_commas, sentinel, r.failure);
     r.data->src = src;
     r.data->base[0] = src;
     r.data->base[1] = r.data->arena.data();
@@ -172,22 +172,6 @@ void check_string(const std::string& content)
     }
 }
 
-// accept() stores no nodes: it must accept and reject what json::accept does, for all options and for inputs with
-// and without a terminating NUL
-void check_accept(const std::string& text)
-{
-    CAPTURE(text)
-    const std::vector<char> bytes(text.begin(), text.end());
-    for (int options = 0; options < 4; ++options)
-    {
-        const bool comments = (options & 1) != 0;
-        const bool trailing_commas = (options & 2) != 0;
-        const bool accepted = json::accept(text, comments, trailing_commas);
-        CHECK(nlohmann::json_document::accept(text, comments, trailing_commas) == accepted);
-        CHECK(nlohmann::json_document::accept(bytes, comments, trailing_commas) == accepted);
-    }
-}
-
 // a small deterministic generator of documents
 struct generator
 {
@@ -439,119 +423,6 @@ TEST_CASE("json_view builder")
         }
     }
 
-    SECTION("accept() without an index")
-    {
-        for (const char* text :
-                {
-                    "", " ", "\n", "null", "nul", "true", "[", "]", "[]", "{}", "[1,2,3]", "[1,2,3", "[1,2,3,]", "{\"a\":1,}", "{\"a\"}", "{\"a\":}",
-                    "[1] x", "[1][2]", "\xEF\xBB\xBF[1]", "[\"a\\", "[\"\\u12\"]", "[\"\\ud800\"]", "[\"\x01\"]", "[\"\xff\"]", "[01]", "[1.]",
-                    "[.5]", "[-]", "[1e]", "// c\n[1]", "/* c */ {\"a\" /* x */ : 1}", "/* c", "[1] // c", "1e400", "-1e400", "123456789012345678901234567890",
-                    "{\"a\":1,\"a\":2}", "[[[]]]", "\"\\u00e4\\n\\ud83d\\ude00\""
-                })
-        {
-            check_accept(text);
-        }
-        // a null byte inside the text, and after it
-        check_accept(std::string("[1,\0]", 5));
-        check_accept(std::string("[1]\0", 4));
-        check_accept(std::string("\0", 1));
-
-        // generated documents and damaged copies, as for the builder above
-        generator g;
-        for (int i = 0; i < 2000; ++i)
-        {
-            std::string text;
-            g.value(text, 0);
-            check_accept(text);
-            std::string damaged = text;
-            const auto at = static_cast<std::size_t>(g.r(static_cast<int>(damaged.size())));
-            static const char replacements[] = {'x', '"', '\\', ',', ':', ']', '}', '[', '{', '1', '-', '.', 'e', '\0', '\n', '/'}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-            damaged[at] = replacements[g.r(16)];
-            check_accept(damaged);
-            check_accept(text.substr(0, at));
-        }
-
-        // nesting beyond the 64 levels that are kept on the builder's own stack, closed and not closed
-        for (const std::size_t depth :
-                {
-                    63, 64, 65, 66, 200, 1000
-                })
-        {
-            check_accept(std::string(depth, '[') + std::string(depth, ']'));
-            check_accept(std::string(depth, '[') + std::string(depth - 1, ']'));
-            std::string objects;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                objects += "{\"k\":";
-            }
-            objects += "1" + std::string(depth, '}');
-            check_accept(objects);
-            check_accept(objects.substr(0, objects.size() - 1));
-        }
-
-        // objects with enough members to get a hash index when they are indexed (and duplicate keys)
-        std::string large = "{";
-        for (int i = 0; i < 300; ++i)
-        {
-            large += (i == 0 ? "\"k" : ",\"k") + std::to_string(i % 200) + "\":" + std::to_string(i);
-        }
-        check_accept(large + "}");
-        check_accept(large);
-        check_accept("[" + large + "},{" + large.substr(1) + "}]");
-
-        // the overflow check uses the floating-point type of the document
-        using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
-        for (const char* text :
-                {
-                    "1e39", "-1e39", "3.4028235e38", "3.4028236e38", "[1.5e38, 3.5e38]", "{\"a\": 1e-50, \"b\": 1e39}", "340282356779733661637539395458142568448"
-                })
-        {
-            CAPTURE(text)
-            CHECK(nlohmann::basic_json_document<float_json>::accept(text) == float_json::accept(text));
-        }
-
-        // strings are checked and not decoded: runs of text of every length from 0 to 40 between valid and invalid
-        // escapes, UTF-8 sequences and control characters, in values and in keys, cut near the end of the text
-        const std::array<const char*, 9> valid = {{"\\n", "\\\"", "\\\\", "\\/", "\\t", "\\u00e4", "\\u20ac", "\\ud83d\\ude00", "\\u0000"}};
-        const std::array<const char*, 12> invalid = {{"\\x", "\\ud800", "\\udc00", "\\u12G4", "\\u12", "\\ud83dx", "\\ud83d\\u0041", "\\ud83d\\ud83d", "\\", "\x01", "\x1f", "\x7f"}};
-        const std::array<const char*, 6> utf8 = {{"\xc3\xa4", "\xe2\x82\xac", "\xf0\x9f\x98\x80", "\xc3", "\xff", "\x80"}};
-        std::mt19937 rng(2029); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
-        for (std::size_t run = 0; run <= 40; ++run)
-        {
-            for (int i = 0; i < 30; ++i)
-            {
-                std::string content = std::string(rng() % 20, 'a');
-                const auto pieces = 1 + (rng() % 6);
-                for (unsigned k = 0; k < pieces; ++k)
-                {
-                    content += valid[rng() % valid.size()];
-                    content += std::string(k == 0 ? run : rng() % 41, static_cast<char>('b' + (rng() % 20)));
-                    switch (rng() % 8)
-                    {
-                        case 0:
-                            content += utf8[rng() % 3];
-                            break;
-                        case 1:
-                            content += utf8[rng() % utf8.size()];
-                            break;
-                        case 2:
-                            content += invalid[rng() % invalid.size()];
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                for (const std::string& text :
-                        {
-                            "[\"" + content + "\"]", "{\"" + content + "\":1}", "[\"" + content, "[\"" + content.substr(0, content.size() - (rng() % 4)) + "\"]"
-                        })
-                {
-                    check_accept(text);
-                }
-            }
-        }
-    }
-
     SECTION("test files")
     {
         for (const char* name :

tests/src/unit-json_view_from_json.cpp

@@ -39,6 +39,7 @@ using nlohmann::ordered_json_document;
 
 #ifdef JSON_HAS_CPP_17
     #include <optional>
+    #include <string_view>
 #endif
 
 // NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair; same() compares floating-point values on purpose
@@ -469,5 +470,70 @@ TEST_CASE("json_view from_json")
 #endif
 }
 
+#ifdef JSON_HAS_CPP_17
+namespace view_from_json
+{
+// a string_view member is not copied: it points into the source text or, for a
+// string with escape sequences, into the buffer of decoded strings of the document
+struct named_view
+{
+    // initialized for GCC -Weffc++
+    // NOLINTNEXTLINE(readability-redundant-member-init)
+    std::string_view name{};
+    int n = 0;
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(named_view, name, n)
+};
+}  // namespace view_from_json
+
+TEST_CASE("json_view from_json: string_view members borrow from the document")
+{
+    using view_from_json::named_view;
+
+    // whether all of s is inside the bytes of text
+    const auto within = [](std::string_view s, std::string_view text)
+    {
+        const auto first = reinterpret_cast<std::uintptr_t>(text.data());
+        const auto begin = reinterpret_cast<std::uintptr_t>(s.data());
+        return begin >= first && begin + s.size() <= first + text.size();
+    };
+
+    SECTION("a string without escapes points into the source text")
+    {
+        const std::string text = R"({"name": "hello", "n": 1})";
+        const json_document d = json_document::parse(text);
+        REQUIRE_FALSE(d.owns_source());
+        const named_view r = d.root().get<named_view>();
+        CHECK(r.name == "hello");
+        CHECK(r.n == 1);
+        CHECK(within(r.name, text));
+        CHECK(within(r.name, d.source()));
+    }
+
+    SECTION("a string with escapes points into the document, not into the source text")
+    {
+        const std::string text = R"({"name": "a\nb", "n": 2})";
+        json_document d = json_document::parse(text);
+        REQUIRE_FALSE(d.owns_source());
+        const named_view r = d.root().get<named_view>();
+        CHECK(r.name == "a\nb");
+        CHECK(r.n == 2);
+        CHECK_FALSE(within(r.name, text));
+        // valid as long as the document is alive, even if the document is moved
+        const json_document moved = std::move(d);
+        CHECK(r.name == "a\nb");
+        CHECK(moved.root().get<named_view>().name == r.name);
+    }
+
+    SECTION("a document that owns its text keeps the members readable while it is alive")
+    {
+        const json_document d = json_document::parse(std::string(R"({"name": "owned", "n": 3})"));
+        REQUIRE(d.owns_source());
+        const named_view r = d.root().get<named_view>();
+        CHECK(r.name == "owned");
+        CHECK(within(r.name, d.source()));
+    }
+}
+#endif
+
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
 DOCTEST_GCC_SUPPRESS_WARNING_POP