Report one-character non-numeric array indices like basic_json in the view

Develop's #5800 made basic_json report a JSON pointer array index such as
"/a" as parse_error.109 instead of out_of_range.404, as longer ones were;
the view's array_index() follows, with "-" and the empty token still
unresolved.

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

cmake/ci.cmake

@@ -613,8 +613,9 @@ foreach(SRC_FILE ${SRC_FILES})
     add_executable(single_${RELATIVE_SRC_FILE} EXCLUDE_FROM_ALL ${PROJECT_BINARY_DIR}/src_single/${RELATIVE_SRC_FILE}.cpp)
     target_include_directories(single_${RELATIVE_SRC_FILE} PRIVATE ${PROJECT_SOURCE_DIR}/include)
     target_compile_features(single_${RELATIVE_SRC_FILE} PRIVATE cxx_std_11)
-    if(RELATIVE_SRC_FILE STREQUAL "json")
-        # see below: report the diagnostics of json.hpp without --error, so they do not fail the build
+    if(RELATIVE_SRC_FILE STREQUAL "json" OR RELATIVE_SRC_FILE STREQUAL "json_literals")
+        # see below: report the diagnostics of json.hpp and json_literals.hpp without --error, so they
+        # do not fail the build
         set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${IWYU_TOOL} -Xiwyu --max_line_length=300)
     else()
         set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "${iwyu_path_and_options}")
@@ -628,31 +629,18 @@ foreach(SRC_FILE ${SRC_FILES})
     # reporting its diagnostics (informational, via CXX_INCLUDE_WHAT_YOU_USE above) but exclude it
     # from the hard gate below so a fresh IWYU/compiler combination does not fail this target on a
     # nondeterministic suggestion for a header that already re-exports everything on purpose.
-    if(NOT RELATIVE_SRC_FILE STREQUAL "json")
+    # json_literals.hpp and json.hpp include each other on purpose (json.hpp includes it at its end
+    # unless JSON_NO_AUTOMATIC_UDLS is defined), and IWYU, not following the cycle, suggests replacing
+    # json.hpp with json_fwd.hpp although the literals need the complete basic_json; exclude it, too.
+    if(NOT RELATIVE_SRC_FILE STREQUAL "json" AND NOT RELATIVE_SRC_FILE STREQUAL "json_literals")
         list(APPEND single_binaries_tus src_single/${RELATIVE_SRC_FILE}.cpp)
     endif()
 endforeach()
 
-# The checks above look at each header on its own. Client code that includes only <nlohmann/json.hpp>
-# must not be told by include analyzers to include another nlohmann header for what it uses
-# (issue #5812): json.hpp marks those includes "IWYU pragma: export", and both IWYU and clang-tidy's
-# misc-include-cleaner (disabled in .clang-tidy for the library itself) check these clients.
-file(GLOB CONSUMER_FILES ${PROJECT_SOURCE_DIR}/tests/iwyu_consumer/*.cpp)
-foreach(CONSUMER_FILE ${CONSUMER_FILES})
-    get_filename_component(CONSUMER_NAME "${CONSUMER_FILE}" NAME_WE)
-    add_executable(iwyu_consumer_${CONSUMER_NAME} EXCLUDE_FROM_ALL ${CONSUMER_FILE})
-    target_include_directories(iwyu_consumer_${CONSUMER_NAME} PRIVATE ${PROJECT_SOURCE_DIR}/include)
-    target_compile_features(iwyu_consumer_${CONSUMER_NAME} PRIVATE cxx_std_11)
-    list(APPEND single_binaries iwyu_consumer_${CONSUMER_NAME})
-    list(APPEND single_binaries_tus ${CONSUMER_FILE})
-endforeach()
-
 if(IWYU_TOOL_PY)
     add_custom_target(ci_single_binaries
         DEPENDS ${single_binaries}
         COMMAND ${IWYU_TOOL_PY} -p ${PROJECT_BINARY_DIR} ${single_binaries_tus} -- ${iwyu_options}
-        COMMAND ${CLANG_TIDY_TOOL} -p ${PROJECT_BINARY_DIR} --checks=-*,misc-include-cleaner --warnings-as-errors=* ${CONSUMER_FILES}
-        VERBATIM
         COMMENT "Check if headers are self-contained"
     )
 else()

docs/mkdocs/docs/api/basic_json/diff.md

@@ -59,7 +59,6 @@ Currently, only `remove`, `add`, and `replace` operations are generated.
 - [patch](patch.md) applies a JSON Patch
 - [patch_inplace](patch_inplace.md) applies a JSON Patch in place
 - [merge_patch](merge_patch.md) applies a JSON Merge Patch
-- [merge_diff](merge_diff.md) creates a diff as a JSON Merge Patch
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/index.md

@@ -285,7 +285,6 @@ Access to the JSON value
 ### JSON Merge Patch functions
 
 - [**merge_patch**](merge_patch.md) - applies a JSON Merge Patch
-- [**merge_diff**](merge_diff.md) (_static_) - creates a diff as a JSON Merge Patch
 
 ## Static functions
 

docs/mkdocs/docs/api/basic_json/merge_diff.md

@@ -1,79 +0,0 @@
-# <small>nlohmann::basic_json::</small>merge_diff
-
-```cpp
-static basic_json merge_diff(const basic_json& source,
-                             const basic_json& target);
-```
-
-Creates a [JSON Merge Patch](https://tools.ietf.org/html/rfc7396) so that value `source` can be changed into the value
-`target` by calling the [`merge_patch`](merge_patch.md) function. The patch contains only what differs: changed and
-added members with their new values, and removed members with the value `#!json null`. Nested objects are compared
-member by member; any other value that differs, including an array, is replaced as a whole.
-
-For two JSON values `source` and `target`, where `target` contains no object member whose value is `#!json null`, the
-following code always yields `#!cpp true`:
-```cpp
-basic_json patched = source;
-patched.merge_patch(merge_diff(source, target));
-patched == target;
-```
-
-## Parameters
-
-`source` (in)
-:   JSON value to compare from
-
-`target` (in)
-:   JSON value to compare against
-
-## Return value
-
-a JSON Merge Patch to convert the `source` to `target`
-
-## Exception safety
-
-Strong guarantee: `source` and `target` are never modified.
-
-## Complexity
-
-Linear in the total number of values (including nested ones) in `source` and `target`, times the cost of a key-based
-object operation (looking up a key, or adding one to the patch): logarithmic for [`json`](../json.md), and linear for
-[`ordered_json`](../ordered_json.md) (see [`ordered_map` complexity](../ordered_map.md#complexity)). For
-`ordered_json`, diffing two objects with `n` and `m` members therefore takes O((n+m)²).
-
-## Notes
-
-- A merge patch uses `#!json null` to remove a member, so it cannot set a member to `#!json null`. As in RFC 7396, a
-  `#!json null` member of `target` is treated as absent: the patch removes the member from `source` instead of setting
-  it to `#!json null`. A member that is `#!json null` in both `source` and `target` is unchanged and left out of the
-  patch, so `source` keeps it.
-- A merge patch cannot reorder object members, and [`merge_patch`](merge_patch.md) appends added members at the end.
-  For [`ordered_json`](../ordered_json.md), the patched value therefore has the same members as `target`, but not
-  necessarily in the same order, and may compare unequal to it. The patch lists changed and removed members in the
-  order of `source`, followed by added members in the order of `target`.
-
-## Examples
-
-??? example
-
-    The following code shows how a JSON Merge Patch is created as a diff for two JSON values.
-
-    ```cpp
-    --8<-- "examples/merge_diff.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/merge_diff.output"
-    ```
-
-## See also
-
-- [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
-- [merge_patch](merge_patch.md) applies a JSON Merge Patch
-- [diff](diff.md) creates a diff as a JSON Patch
-
-## Version history
-
-- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json/merge_patch.md

@@ -67,7 +67,6 @@ returned by `#!cpp (*this)[key]`); it is read as it was when `merge_patch()` was
 
 - [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
 - [patch](patch.md) apply a JSON patch
-- [merge_diff](merge_diff.md) creates a diff as a JSON Merge Patch
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/operator_eq.md

@@ -11,10 +11,12 @@ template<typename ScalarType>
 bool operator==(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 
 // since C++20
-bool operator==(const_reference rhs) const noexcept;             // (1)
+class basic_json {
+    bool operator==(const_reference rhs) const noexcept;              // (1)
 
-template<typename ScalarType>
-bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
+    template<typename ScalarType>
+    bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
+};
 ```
 
 1. Compares two JSON values for equality according to the following rules:

docs/mkdocs/docs/api/basic_json/operator_spaceship.md

@@ -2,10 +2,12 @@
 
 ```cpp
 // since C++20
-std::partial_ordering operator<=>(const_reference rhs) const noexcept;                   // (1)
+class basic_json {
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept;  // (1)
 
-template<typename ScalarType>
-std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see below */); // (2)
+    template<typename ScalarType>
+    std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see below */); // (2)
+};
 ```
 
 1. 3-way compares two JSON values producing a result of type `std::partial_ordering` according to the following rules:

docs/mkdocs/docs/api/json_pointer/operator_eq.md

@@ -18,11 +18,13 @@ bool operator==(
     const json_pointer<RefStringTypeRhs>& rhs);                     // (2)
 
 // since C++20
-template<typename RefStringTypeRhs>
-bool operator==(
-    const json_pointer<RefStringTypeRhs>& rhs) const noexcept;      // (1)
+class json_pointer {
+    template<typename RefStringTypeRhs>
+    bool operator==(
+        const json_pointer<RefStringTypeRhs>& rhs) const noexcept;  // (1)
 
-bool operator==(const string_t& rhs) const;                         // (2)
+    bool operator==(const string_t& rhs) const;                     // (2)
+};
 ```
 
 1. Compares two JSON pointers for equality by comparing their reference tokens.

docs/mkdocs/docs/api/json_pointer/operator_spaceship.md

@@ -2,8 +2,10 @@
 
 ```cpp
 // since C++20
-template<typename RefStringTypeRhs>
-std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept; // *NOPAD*
+class json_pointer {
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept; // *NOPAD*
+};
 ```
 
 3-way compares two JSON pointers by lexicographically comparing their sequences of reference tokens: corresponding

docs/mkdocs/docs/examples/merge_diff.cpp

@@ -1,51 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-using namespace nlohmann::literals;
-
-int main()
-{
-    // the source document
-    json source = R"(
-        {
-            "title": "Goodbye!",
-            "author": {
-                "givenName": "John",
-                "familyName": "Doe"
-            },
-            "tags": [
-                "example",
-                "sample"
-            ],
-            "content": "This will be unchanged"
-        }
-    )"_json;
-
-    // the target document
-    json target = R"(
-        {
-            "title": "Hello!",
-            "author": {
-                "givenName": "John"
-            },
-            "tags": [
-                "example"
-            ],
-            "content": "This will be unchanged",
-            "phoneNumber": "+01-123-456-7890"
-        }
-    )"_json;
-
-    // create the patch
-    json patch = json::merge_diff(source, target);
-
-    // roundtrip
-    json patched_source = source;
-    patched_source.merge_patch(patch);
-
-    // output patch and roundtrip result
-    std::cout << std::setw(4) << patch << "\n\n"
-              << std::setw(4) << patched_source << std::endl;
-}

docs/mkdocs/docs/examples/merge_diff.output

@@ -1,22 +0,0 @@
-{
-    "author": {
-        "familyName": null
-    },
-    "phoneNumber": "+01-123-456-7890",
-    "tags": [
-        "example"
-    ],
-    "title": "Hello!"
-}
-
-{
-    "author": {
-        "givenName": "John"
-    },
-    "content": "This will be unchanged",
-    "phoneNumber": "+01-123-456-7890",
-    "tags": [
-        "example"
-    ],
-    "title": "Hello!"
-}

docs/mkdocs/docs/features/merge_patch.md

@@ -9,9 +9,6 @@ syntax that closely mimics the document being modified. Unlike [JSON Patch](json
 express every kind of change (e.g., it cannot reorder array elements or remove a specific array element), but it is
 easier to read and write for object-shaped documents.
 
-The function [`merge_diff`](../api/basic_json/merge_diff.md) creates a merge patch that changes one JSON value into
-another.
-
 !!! tip "Not a general deep merge"
 
     A merge patch is not a general deep merge: a `#!json null` value in the patch deletes the key from the target.
@@ -38,5 +35,4 @@ another.
 - [JSON Patch and Diff](json_patch.md) - a more expressive alternative that describes a sequence of operations
 - [JSON Pointer](json_pointer.md) - the addressing scheme used by JSON Patch
 - Function [`merge_patch`](../api/basic_json/merge_patch.md)
-- Function [`merge_diff`](../api/basic_json/merge_diff.md)
 - Function [`update`](../api/basic_json/update.md) - merge objects, optionally recursively

docs/mkdocs/docs/home/architecture.md

@@ -261,11 +261,9 @@ The lexer detects two optional extensions at compile time. Only `iterator_input_
 random-access input of single-byte characters:
 
 - `supports_seek`, `get_consumed_count()`, and `copy_consumed_range()` let the lexer reconstruct already consumed input
-  for error messages instead of copying every character it reads. With `get_read_count()` and
-  `count_consumed_lines()`, the lexer also derives the read position from the adapter and counts lines only when an
-  error needs them, instead of counting characters and lines on every read.
+  for error messages instead of copying every character it reads.
 - `supports_bulk_scan`, `bulk_data()`, `bulk_remaining()`, and `bulk_skip()` let the lexer scan strings directly in
-  contiguous memory, several bytes at a time, and skip the spaces that indent a line in 8-byte steps.
+  contiguous memory, several bytes at a time.
 
 The function `input_adapter` picks the right adapter for the argument passed to `parse`, `accept`, `sax_parse`, or the
 `from_*` functions:

docs/mkdocs/mkdocs.yml

@@ -183,7 +183,6 @@ nav:
           - 'json_serializer': api/basic_json/json_serializer.md
           - 'max_size': api/basic_json/max_size.md
           - 'meta': api/basic_json/meta.md
-          - 'merge_diff': api/basic_json/merge_diff.md
           - 'merge_patch': api/basic_json/merge_patch.md
           - 'number_float_t': api/basic_json/number_float_t.md
           - 'number_integer_t': api/basic_json/number_integer_t.md

include/nlohmann/detail/input/input_adapters.hpp

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include <algorithm> // count, find, min
+#include <algorithm> // min
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint32_t
 #include <cstring> // strlen
-#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next, reverse_iterator
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
 #include <streambuf> // streambuf
 #include <string> // string, char_traits
 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
@@ -297,7 +297,6 @@ class iterator_input_adapter
             return result;
         }
 
-        ++eof_reads;
         return char_traits<char_type>::eof();
     }
 
@@ -307,26 +306,6 @@ class iterator_input_adapter
         return static_cast<std::size_t>(std::distance(begin, current));
     }
 
-    // number of get_character() calls so far, including those that returned
-    // EOF; the lexer derives its position from it (see lexer::lazy_position)
-    std::size_t get_read_count() const
-    {
-        return get_consumed_count() + eof_reads;
-    }
-
-    // number of newlines in the consumed range [0, last_index); @a line_start
-    // is set to the index after the last of them (0 if there is none); only
-    // valid when supports_seek
-    std::size_t count_consumed_lines(std::size_t last_index, std::size_t& line_start) const
-    {
-        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
-        const auto newline = char_traits<char_type>::to_char_type('\n');
-        using reverse_it = std::reverse_iterator<IteratorType>;
-        const auto last_newline = std::find(reverse_it(to), reverse_it(begin), newline);
-        line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
-        return static_cast<std::size_t>(std::count(begin, last_newline.base(), newline));
-    }
-
     // append the already-consumed characters in the half-open range
     // [first_index, last_index) to @a out; only valid when supports_seek
     template<typename ContainerType>
@@ -443,8 +422,6 @@ class iterator_input_adapter
     IteratorType begin;
     IteratorType current;
     SentinelType end;
-    /// number of get_character() calls that returned EOF
-    std::size_t eof_reads = 0;
 
     template<typename BaseInputAdapter, size_t T>
     friend struct wide_string_input_helper;

include/nlohmann/detail/input/json_sax.hpp

@@ -217,7 +217,7 @@ struct diagnostic_positions
         {
             // Lexer has read the first character of the container, so
             // subtract 1 from the position to get the correct start position.
-            v.start_position = lexer->get_chars_read_total() - 1;
+            v.start_position = lexer->get_position() - 1;
         }
     }
 
@@ -231,7 +231,7 @@ struct diagnostic_positions
         if (lexer)
         {
             // Lexer's position is past the closing brace or bracket, so set that as the end position.
-            v.end_position = lexer->get_chars_read_total();
+            v.end_position = lexer->get_position();
         }
     }
 
@@ -247,7 +247,7 @@ struct diagnostic_positions
             // Lexer has read past the current field value, so set the end position to the current position.
             // The start position will be set below based on the length of the string representation
             // of the value.
-            v.end_position = lexer->get_chars_read_total();
+            v.end_position = lexer->get_position();
 
             switch (v.type())
             {

include/nlohmann/detail/input/lexer.hpp

@@ -17,7 +17,6 @@
 #include <utility> // move
 #include <vector> // vector
 
-#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/number_parse.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
@@ -187,15 +186,6 @@ class lexer : public lexer_base<BasicJsonType>
     static constexpr bool lazy_token_string =
         input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
 
-    /// whether the read position is derived from the input adapter on demand
-    /// instead of being counted on every scanned character. Seekable adapters
-    /// know how much input they consumed and can revisit it, so
-    /// chars_read_total is the adapter's read count (minus a pending unget),
-    /// and line and column are recomputed from the consumed input only when
-    /// get_position() is called (errors). Counting per character kept two
-    /// increments and a newline check in the hot path of every get().
-    static constexpr bool lazy_position = lazy_token_string;
-
     /// whether a simulated unget can be passed on to the input adapter, which
     /// then leaves the character in the input; see
     /// input_adapter_supports_lookahead
@@ -205,9 +195,7 @@ class lexer : public lexer_base<BasicJsonType>
     /// whether string scanning may bulk-consume runs of ordinary characters
     /// directly from a contiguous input buffer (SWAR fast path). This requires
     /// the token to be reconstructible lazily (lazy_token_string), so bypassing
-    /// the per-character capture in get() cannot lose error diagnostics. It
-    /// also implies lazy_position, so the bulk paths need not advance the
-    /// position counters.
+    /// the per-character capture in get() cannot lose error diagnostics.
     static constexpr bool bulk_scan =
         lazy_token_string
         && input_adapter_supports_bulk_scan<InputAdapterType>(is_detected<detect_supports_bulk_scan, InputAdapterType> {});
@@ -235,13 +223,13 @@ class lexer : public lexer_base<BasicJsonType>
 
     /// contiguous input: try to decode the 4 hex digits following `\\u`
     /// directly from the input buffer via hex_codepoint(), instead of 4 calls
-    /// to get(). On success, advances the adapter exactly as those 4 get()
-    /// calls would (bulk_scan implies lazy_position, so there are no position
-    /// counters to advance) and leaves @a current holding the last of
+    /// to get(). On success, advances the adapter and the position counters
+    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
+    /// only the flat counters move) and leaves @a current holding the last of
     /// the 4 digits, just as the last such get() would; the codepoint is
-    /// written to @a out. Makes no state change and returns false for a
+    /// written to @a out. Makes no state change and returns false - for a
     /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
-    /// being a hex digit, so the caller falls back unchanged to the
+    /// being a hex digit - so the caller falls back unchanged to the
     /// per-character loop, which then reports the same diagnostic (stopping
     /// at the first invalid digit) as before this optimization.
     bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
@@ -257,6 +245,9 @@ class lexer : public lexer_base<BasicJsonType>
             return false;
         }
         ia.bulk_skip(4);
+        // a hex digit is never a newline, so only the flat counters advance
+        position.chars_read_total += 4;
+        position.chars_read_current_line += 4;
         current = char_traits<char_type>::to_int_type(raw[3]);
         out = codepoint;
         return true;
@@ -386,6 +377,10 @@ class lexer : public lexer_base<BasicJsonType>
         }
         token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), pos);
         ia.bulk_skip(pos);
+        // the run contains no newline (all bytes < 0x20 are treated as special),
+        // so only the flat character counters advance
+        position.chars_read_total += pos;
+        position.chars_read_current_line += pos;
     }
 
     /// streaming input: no bulk fast path
@@ -1621,6 +1616,8 @@ scan_number_done:
             if (JSON_HEDLEY_LIKELY(integer_result != token_type::uninitialized))
             {
                 ia.bulk_skip(len - 1);
+                position.chars_read_total += (len - 1);
+                position.chars_read_current_line += (len - 1);
                 return integer_result;
             }
             // The value does not fit an integer, so this token converts as a
@@ -1637,6 +1634,8 @@ scan_number_done:
         decimal_point_position = dot_index;
 
         ia.bulk_skip(len - 1);
+        position.chars_read_total += (len - 1);
+        position.chars_read_current_line += (len - 1);
 
         return convert_number(number_type, mantissa_end);
     }
@@ -1687,7 +1686,7 @@ scan_number_done:
 
 #if JSON_DIAGNOSTIC_POSITIONS
         // the first character of the token has already been read, hence the -1
-        token_start_position = get_chars_read_total() - 1;
+        token_start_position = position.chars_read_total - 1;
 #endif
 
         note_token_start(std::integral_constant<bool, lazy_token_string> {});
@@ -1740,15 +1739,6 @@ scan_number_done:
     /// per-character position counters (line-count-on-'\n' bookkeeping is
     /// handled afterwards, in track_after_read(), once `current` is known)
     void advance_position() noexcept
-    {
-        advance_position_impl(std::integral_constant<bool, lazy_position> {});
-    }
-
-    /// seekable adapter: the position is derived from the adapter on demand
-    void advance_position_impl(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: count the character
-    void advance_position_impl(std::false_type /*lazy*/) noexcept
     {
         ++position.chars_read_total;
         ++position.chars_read_current_line;
@@ -1762,16 +1752,7 @@ scan_number_done:
         // seekable adapters reconstruct the token lazily on error (see
         // get_token_string), so the eager per-character copy is skipped
         capture_char(std::integral_constant<bool, lazy_token_string> {});
-        track_newline(std::integral_constant<bool, lazy_position> {});
-        return current;
-    }
 
-    /// seekable adapter: lines are counted on demand in get_position()
-    void track_newline(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: start a new line after reading a newline
-    void track_newline(std::false_type /*lazy*/) noexcept
-    {
         if (current == '\n')
         {
             ++position.lines_read;
@@ -1780,6 +1761,8 @@ scan_number_done:
             chars_read_before_newline = position.chars_read_current_line;
             position.chars_read_current_line = 0;
         }
+
+        return current;
     }
 
     /*!
@@ -1823,22 +1806,12 @@ scan_number_done:
     We implement unget by setting variable next_unget to true. The input is not
     changed - we just simulate ungetting by modifying chars_read_total,
     chars_read_current_line, and token_string. The next call to get() will
-    behave as if the unget character is read again. With lazy_position, the
-    pending next_unget is all get_chars_read_total() needs.
+    behave as if the unget character is read again.
     */
     void unget()
     {
         next_unget = true;
-        unget_position(std::integral_constant<bool, lazy_position> {});
-        uncapture_char(std::integral_constant<bool, lazy_token_string> {});
-    }
 
-    /// seekable adapter: get_chars_read_total() accounts for next_unget
-    void unget_position(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: step the counters back over the ungotten character
-    void unget_position(std::false_type /*lazy*/) noexcept
-    {
         --position.chars_read_total;
 
         // in case we "unget" a newline, we have to also decrement the lines_read
@@ -1861,6 +1834,8 @@ scan_number_done:
         {
             --position.chars_read_current_line;
         }
+
+        uncapture_char(std::integral_constant<bool, lazy_token_string> {});
     }
 
     /// adapter without lookahead: nothing to do (see release_lookahead)
@@ -1931,21 +1906,10 @@ scan_number_done:
     // diagnostics
     /////////////////////
 
-    /*!
-    @brief return the number of characters read so far
-
-    Unlike get_position(), this is O(1) for all adapters, so it may be called
-    for every value (JSON_DIAGNOSTIC_POSITIONS).
-    */
-    std::size_t get_chars_read_total() const noexcept
-    {
-        return get_chars_read_total_impl(std::integral_constant<bool, lazy_position> {});
-    }
-
     /// return position of last read token
-    position_t get_position() const
+    constexpr position_t get_position() const noexcept
     {
-        return get_position_impl(std::integral_constant<bool, lazy_position> {});
+        return position;
     }
 
     /*!
@@ -1982,43 +1946,6 @@ scan_number_done:
     }
 #endif
 
-  private:
-    /// seekable adapter: every get() either read from the adapter (including
-    /// reads at EOF, which get() counts as characters as well) or replayed an
-    /// ungotten character, so the count is the adapter's read count minus a
-    /// still pending unget
-    std::size_t get_chars_read_total_impl(std::true_type /*lazy*/) const noexcept
-    {
-        return ia.get_read_count() - (next_unget ? 1u : 0u);
-    }
-
-    /// streaming adapter: the counter is maintained by get() and unget()
-    std::size_t get_chars_read_total_impl(std::false_type /*lazy*/) const noexcept
-    {
-        return position.chars_read_total;
-    }
-
-    /// seekable adapter: count the lines in the consumed input; O(input read
-    /// so far), but only called on errors
-    position_t get_position_impl(std::true_type /*lazy*/) const
-    {
-        position_t result;
-        result.chars_read_total = get_chars_read_total();
-        // reads at EOF count as characters but are not part of the input
-        const std::size_t consumed = (std::min)(result.chars_read_total, ia.get_consumed_count());
-        std::size_t line_start = 0;
-        result.lines_read = ia.count_consumed_lines(consumed, line_start);
-        result.chars_read_current_line = result.chars_read_total - line_start;
-        return result;
-    }
-
-    /// streaming adapter: the position is maintained by get() and unget()
-    position_t get_position_impl(std::false_type /*lazy*/) const noexcept
-    {
-        return position;
-    }
-
-  public:
     /// seekable adapter: rebuild the last read token from the input on demand
     const std::vector<char_type>& collect_token_chars(std::vector<char_type>& out, std::true_type /*lazy*/) const
     {
@@ -2126,57 +2053,15 @@ scan_number_done:
         // into one that reloads the pointer from memory every character
         do
         {
-            if (current == '\n')
-            {
-                skip_indentation(std::integral_constant<bool, bulk_scan> {});
-            }
             get_ignoring_pending_unget();
         }
         while (current_is_whitespace());
     }
 
-    /*!
-    @brief contiguous input: skip the space indentation that follows a newline
-           8 bytes at a time
-
-    Pretty-printed JSON indents every line with a run of spaces, which the loop
-    in skip_whitespace() would otherwise read one character at a time. The
-    spaces are skipped 8 bytes at a time; the last 7 bytes of the input and any
-    other whitespace are left to that loop. Skipping bypasses get(), which is
-    fine because bulk_scan implies lazy_position: the position is derived from
-    the adapter, not counted per character.
-    */
-    void skip_indentation(std::true_type /*bulk*/)
-    {
-        JSON_ASSERT(!next_unget);
-        const std::size_t remaining = ia.bulk_remaining();
-        if (remaining < 8)
-        {
-            return;
-        }
-        const char* const data = reinterpret_cast<const char*>(ia.bulk_data());
-        std::size_t pos = 0;
-        for (; pos + 8 <= remaining; pos += 8)
-        {
-            // little-endian, so the first byte is the lowest
-            const std::uint64_t non_space = read_eight_bytes(data + pos) ^ 0x2020202020202020ull;
-            if (non_space != 0)
-            {
-                // skip the spaces before the first other byte of this word
-                pos += static_cast<std::size_t>(count_trailing_zeros(non_space)) / 8;
-                break;
-            }
-        }
-        ia.bulk_skip(pos);
-    }
-
-    /// streaming input: no bulk fast path
-    void skip_indentation(std::false_type /*bulk*/) const noexcept {}
-
     token_type scan()
     {
         // initially, skip the BOM
-        if (get_chars_read_total() == 0 && !skip_bom())
+        if (position.chars_read_total == 0 && !skip_bom())
         {
             error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
             return token_type::parse_error;
@@ -2203,7 +2088,7 @@ scan_number_done:
     token_type scan_expecting(token_type expected_type)
     {
         JSON_ASSERT(expected_type == token_type::name_separator || expected_type == token_type::value_separator);
-        JSON_ASSERT(get_chars_read_total() > 0);
+        JSON_ASSERT(position.chars_read_total > 0);
         const char_int_type expected_char = static_cast<unsigned char>((expected_type == token_type::name_separator) ? ':' : ',');
         skip_whitespace();
         if (JSON_HEDLEY_LIKELY(current == expected_char))

include/nlohmann/detail/input/number_parse.hpp

@@ -9,7 +9,6 @@
 
 #pragma once
 
-#include <algorithm> // any_of
 #include <array> // array
 #include <cfloat> // FLT_EVAL_METHOD
 #include <clocale> // localeconv
@@ -262,10 +261,14 @@ JSON_HEDLEY_ALWAYS_INLINE std::uint32_t parse_eight_digits(std::uint64_t v) noex
 /// whether [first, last) contains a digit other than '0'
 inline bool has_nonzero_digit(const char* first, const char* last) noexcept
 {
-    return std::any_of(first, last, [](char c) noexcept
+    for (; first != last; ++first)
     {
-        return c != '0';
-    });
+        if (*first != '0')
+        {
+            return true;
+        }
+    }
+    return false;
 }
 
 /// the value of the validated exponent digits [+-]?[0-9]+ in [first, last),
@@ -987,8 +990,8 @@ void convert_float_locale_aware(StringType& token, std::size_t decimal_point_pos
         {
             std::string buffer(token.data(), token.size());
             buffer.replace(decimal_point_position, 1, decimal_point);
-            strtof_by_type(value, buffer.data(), &endptr);
-            complete = endptr == buffer.data() + buffer.size();
+            strtof_by_type(value, buffer.c_str(), &endptr);
+            complete = endptr == buffer.c_str() + buffer.size();
         }
 
         if (JSON_HEDLEY_LIKELY(complete))

include/nlohmann/detail/input/parser.hpp

@@ -370,7 +370,7 @@ class parser
                     }
                     case token_type::end_of_input:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_chars_read_total() == 1))
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                         {
                             return syntax_error(*sax, "attempting to parse an empty input; check that your input string or stream contains the expected JSON");
                         }
@@ -520,10 +520,8 @@ class parser
     {
         // MSVC 2015 reports C4100 (unreferenced parameter) when SAX::parse_error is static
         static_cast<void>(sax);
-        // computing the position is O(input read so far) for seekable input
-        const position_t position = m_lexer.get_position();
-        return sax.parse_error(position, m_lexer.get_token_string(),
-                               parse_error::create(exception_id::syntax_error, position, message, nullptr));
+        return sax.parse_error(m_lexer.get_position(), m_lexer.get_token_string(),
+                               parse_error::create(exception_id::syntax_error, m_lexer.get_position(), message, nullptr));
     }
 
     std::string exception_message(const token_type expected, const std::string& context)

include/nlohmann/json.hpp

@@ -42,15 +42,10 @@
 // each of these, not only the forward declarations from json_fwd.hpp, so IWYU's suggestion to
 // drop them (nothing in this file otherwise names the type) would break every downstream
 // translation unit that relies on basic_json<>'s defaults actually being usable.
-// export: client code names what these headers declare (nlohmann::json and ordered_json from
-// json_fwd.hpp, adl_serializer for specializations, json_ref behind brace initialization, the
-// NLOHMANN_DEFINE_* and NLOHMANN_JSON_NAMESPACE_* macros, and the literals at the end of this file), and include analyzers must
-// attribute it to this header, not tell clients to include the internal ones (issue #5812).
-// tests/iwyu_consumer checks this.
-#include <nlohmann/adl_serializer.hpp> // IWYU pragma: export
+#include <nlohmann/adl_serializer.hpp> // IWYU pragma: keep
 #include <nlohmann/byte_container_with_subtype.hpp>
 #include <nlohmann/detail/abi_config.hpp>
-#include <nlohmann/detail/abi_macros.hpp> // IWYU pragma: export
+#include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/conversions/from_json.hpp> // IWYU pragma: keep
 #include <nlohmann/detail/conversions/to_json.hpp> // IWYU pragma: keep
 #include <nlohmann/detail/exceptions.hpp>
@@ -67,8 +62,8 @@
 #include <nlohmann/detail/iterators/primitive_iterator.hpp>
 #include <nlohmann/detail/json_custom_base_class.hpp>
 #include <nlohmann/detail/json_pointer.hpp>
-#include <nlohmann/detail/json_ref.hpp> // IWYU pragma: export
-#include <nlohmann/detail/macro_scope.hpp> // IWYU pragma: export
+#include <nlohmann/detail/json_ref.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/detected.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/string_escape.hpp>
@@ -80,7 +75,7 @@
 #include <nlohmann/detail/output/serializer.hpp>
 #include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/value_t.hpp>
-#include <nlohmann/json_fwd.hpp> // IWYU pragma: export
+#include <nlohmann/json_fwd.hpp>
 #include <nlohmann/ordered_map.hpp> // IWYU pragma: keep
 #include <nlohmann/thirdparty/hedley/hedley.hpp>
 
@@ -7433,176 +7428,6 @@ public:
     }
 
   public:
-    /// @brief creates a diff as a JSON Merge Patch
-    /// @sa https://json.nlohmann.me/api/basic_json/merge_diff/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json merge_diff(const basic_json& source, const basic_json& target)
-    {
-        // unless both are objects, the patch is the target itself
-        if (!source.is_object() || !target.is_object())
-        {
-            return target;
-        }
-
-        return merge_diff_recursively(source, target, 0);
-    }
-
-  private:
-    /// @brief two objects @ref merge_diff_iteratively is diffing
-    struct merge_diff_frame
-    {
-        merge_diff_frame(const basic_json* source_, const basic_json* target_)
-            : source(source_), target(target_), member(source_->cbegin()), patch(value_t::object)
-        {}
-
-        // declared for GCC's -Weffc++, as in diff_frame
-        merge_diff_frame(const merge_diff_frame&) = default;
-        merge_diff_frame(merge_diff_frame&&) = default;
-        merge_diff_frame& operator=(const merge_diff_frame&) = default;
-        merge_diff_frame& operator=(merge_diff_frame&&) = default;
-        ~merge_diff_frame() = default;
-
-        /// the objects being diffed
-        const basic_json* source;
-        const basic_json* target;
-        /// the member of source being diffed; advanced once it is done
-        const_iterator member;
-        /// the patch for the members of source diffed so far
-        basic_json patch;
-    };
-
-    /// @brief add the members of object @a target that @a source does not
-    ///        have to the merge patch @a result
-    static void merge_diff_added_members(basic_json& result, const basic_json& source, const basic_json& target)
-    {
-        for (auto it = target.begin(); it != target.end(); ++it)
-        {
-            auto itf = source.find(it.key());
-            if (itf == source.end())
-            {
-                result[it.key()] = it.value();
-            }
-        }
-    }
-
-    /*!
-    @brief @ref merge_diff of two objects at nesting level @a depth
-
-    Diffing two nested objects calls this function again, once per nesting
-    level, so values nested deeply enough would exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    merge_diff_iteratively diffs what is left without the call stack.
-    */
-    static basic_json merge_diff_recursively(const basic_json& source, const basic_json& target, const std::size_t depth)
-    {
-        JSON_ASSERT(source.is_object() && target.is_object());
-
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            return merge_diff_iteratively(source, target);
-        }
-
-        basic_json result(value_t::object);
-
-        for (auto it = source.begin(); it != source.end(); ++it)
-        {
-            auto itf = target.find(it.key());
-            if (itf != target.end())
-            {
-                if (it.value().is_object() && itf.value().is_object())
-                {
-                    auto diff = merge_diff_recursively(it.value(), itf.value(), depth + 1);
-                    if (!diff.empty())
-                    {
-                        result[it.key()] = std::move(diff);
-                    }
-                }
-                else if (it.value() != itf.value())
-                {
-                    result[it.key()] = itf.value();
-                }
-            }
-            else
-            {
-                result[it.key()] = value_t::null;
-            }
-        }
-
-        merge_diff_added_members(result, source, target);
-        return result;
-    }
-
-    /*!
-    @brief @ref merge_diff of two objects without the call stack
-
-    Produces the same patch as @ref merge_diff_recursively, keeping the objects
-    being diffed on an explicit stack instead of descending into them. Two
-    nested objects are still diffed completely before the next member, so the
-    patch has its members in the same order as in the recursive version. Only
-    reached for objects nested more deeply than @ref
-    detail::recursion_depth_limit.
-    */
-    static basic_json merge_diff_iteratively(const basic_json& source, const basic_json& target)
-    {
-        // the patch of source and target, set once their frame is popped
-        basic_json result;
-        std::vector<merge_diff_frame> stack;
-        stack.emplace_back(&source, &target);
-        while (!stack.empty())
-        {
-            // the frame's members are copied out and it is changed through
-            // stack.back(): pushing a frame for nested objects or popping
-            // this one would invalidate a reference to it
-            const basic_json* const s = stack.back().source;
-            const basic_json* const t = stack.back().target;
-            const const_iterator it = stack.back().member;
-
-            if (it != s->cend())
-            {
-                const const_iterator itf = t->find(it.key());
-                if (itf != t->cend())
-                {
-                    if (it.value().is_object() && itf.value().is_object())
-                    {
-                        // member is advanced once their patch is under its key
-                        stack.emplace_back(&it.value(), &itf.value());
-                        continue;
-                    }
-                    if (it.value() != itf.value())
-                    {
-                        stack.back().patch[it.key()] = itf.value();
-                    }
-                }
-                else
-                {
-                    stack.back().patch[it.key()] = value_t::null;
-                }
-                ++stack.back().member;
-                continue;
-            }
-
-            merge_diff_added_members(stack.back().patch, *s, *t);
-
-            // these objects are done: continue with the ones they are in
-            basic_json patch = std::move(stack.back().patch);
-            stack.pop_back();
-            if (stack.empty())
-            {
-                result = std::move(patch);
-            }
-            else
-            {
-                if (!patch.empty())
-                {
-                    stack.back().patch[stack.back().member.key()] = std::move(patch);
-                }
-                ++stack.back().member;
-            }
-        }
-        return result;
-    }
-
     /// @}
 };
 
@@ -7779,7 +7604,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 // where needed.
 #ifndef JSON_NO_AUTOMATIC_UDLS
     // NOLINTNEXTLINE(misc-header-include-cycle): json_literals.hpp includes this header
-    #include <nlohmann/json_literals.hpp> // IWYU pragma: export
+    #include <nlohmann/json_literals.hpp>
 #endif
 
 #endif  // INCLUDE_NLOHMANN_JSON_HPP_

single_include/nlohmann/json.hpp

@@ -42,11 +42,6 @@
 // each of these, not only the forward declarations from json_fwd.hpp, so IWYU's suggestion to
 // drop them (nothing in this file otherwise names the type) would break every downstream
 // translation unit that relies on basic_json<>'s defaults actually being usable.
-// export: client code names what these headers declare (nlohmann::json and ordered_json from
-// json_fwd.hpp, adl_serializer for specializations, json_ref behind brace initialization, the
-// NLOHMANN_DEFINE_* and NLOHMANN_JSON_NAMESPACE_* macros, and the literals at the end of this file), and include analyzers must
-// attribute it to this header, not tell clients to include the internal ones (issue #5812).
-// tests/iwyu_consumer checks this.
 // #include <nlohmann/adl_serializer.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -7571,7 +7566,7 @@ struct adl_serializer
 };
 
 NLOHMANN_JSON_NAMESPACE_END
-// IWYU pragma: export
+// IWYU pragma: keep
 // #include <nlohmann/byte_container_with_subtype.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -7715,7 +7710,7 @@ struct abi_config
 NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/abi_macros.hpp>
-// IWYU pragma: export
+
 // #include <nlohmann/detail/conversions/from_json.hpp>
 // IWYU pragma: keep
 // #include <nlohmann/detail/conversions/to_json.hpp>
@@ -8037,12 +8032,12 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 
-#include <algorithm> // count, find, min
+#include <algorithm> // min
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint32_t
 #include <cstring> // strlen
-#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next, reverse_iterator
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
 #include <streambuf> // streambuf
 #include <string> // string, char_traits
 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
@@ -8331,7 +8326,6 @@ class iterator_input_adapter
             return result;
         }
 
-        ++eof_reads;
         return char_traits<char_type>::eof();
     }
 
@@ -8341,26 +8335,6 @@ class iterator_input_adapter
         return static_cast<std::size_t>(std::distance(begin, current));
     }
 
-    // number of get_character() calls so far, including those that returned
-    // EOF; the lexer derives its position from it (see lexer::lazy_position)
-    std::size_t get_read_count() const
-    {
-        return get_consumed_count() + eof_reads;
-    }
-
-    // number of newlines in the consumed range [0, last_index); @a line_start
-    // is set to the index after the last of them (0 if there is none); only
-    // valid when supports_seek
-    std::size_t count_consumed_lines(std::size_t last_index, std::size_t& line_start) const
-    {
-        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
-        const auto newline = char_traits<char_type>::to_char_type('\n');
-        using reverse_it = std::reverse_iterator<IteratorType>;
-        const auto last_newline = std::find(reverse_it(to), reverse_it(begin), newline);
-        line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
-        return static_cast<std::size_t>(std::count(begin, last_newline.base(), newline));
-    }
-
     // append the already-consumed characters in the half-open range
     // [first_index, last_index) to @a out; only valid when supports_seek
     template<typename ContainerType>
@@ -8477,8 +8451,6 @@ class iterator_input_adapter
     IteratorType begin;
     IteratorType current;
     SentinelType end;
-    /// number of get_character() calls that returned EOF
-    std::size_t eof_reads = 0;
 
     template<typename BaseInputAdapter, size_t T>
     friend struct wide_string_input_helper;
@@ -8999,6 +8971,32 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <utility> // move
 #include <vector> // vector
 
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/number_parse.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2021 The fast_float authors <https://github.com/fastfloat/fast_float>
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cfloat> // FLT_EVAL_METHOD
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdint> // int64_t, uint64_t
+#include <cstdlib> // strtof, strtod, strtold
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <type_traits> // conditional, integral_constant, true_type, false_type
+#include <utility> // move
+
 // #include <nlohmann/detail/bit_ops.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -9132,35 +9130,6 @@ JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const char* p) noexcept
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/number_parse.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2021 The fast_float authors <https://github.com/fastfloat/fast_float>
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-
-
-#include <algorithm> // any_of
-#include <array> // array
-#include <cfloat> // FLT_EVAL_METHOD
-#include <clocale> // localeconv
-#include <cstddef> // size_t
-#include <cstdint> // int64_t, uint64_t
-#include <cstdlib> // strtof, strtod, strtold
-#include <cstring> // memcpy
-#include <limits> // numeric_limits
-#include <string> // string
-#include <type_traits> // conditional, integral_constant, true_type, false_type
-#include <utility> // move
-
-// #include <nlohmann/detail/bit_ops.hpp>
-
 // #include <nlohmann/detail/input/pow5_table.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -9778,10 +9747,14 @@ JSON_HEDLEY_ALWAYS_INLINE std::uint32_t parse_eight_digits(std::uint64_t v) noex
 /// whether [first, last) contains a digit other than '0'
 inline bool has_nonzero_digit(const char* first, const char* last) noexcept
 {
-    return std::any_of(first, last, [](char c) noexcept
+    for (; first != last; ++first)
     {
-        return c != '0';
-    });
+        if (*first != '0')
+        {
+            return true;
+        }
+    }
+    return false;
 }
 
 /// the value of the validated exponent digits [+-]?[0-9]+ in [first, last),
@@ -10503,8 +10476,8 @@ void convert_float_locale_aware(StringType& token, std::size_t decimal_point_pos
         {
             std::string buffer(token.data(), token.size());
             buffer.replace(decimal_point_position, 1, decimal_point);
-            strtof_by_type(value, buffer.data(), &endptr);
-            complete = endptr == buffer.data() + buffer.size();
+            strtof_by_type(value, buffer.c_str(), &endptr);
+            complete = endptr == buffer.c_str() + buffer.size();
         }
 
         if (JSON_HEDLEY_LIKELY(complete))
@@ -11092,15 +11065,6 @@ class lexer : public lexer_base<BasicJsonType>
     static constexpr bool lazy_token_string =
         input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
 
-    /// whether the read position is derived from the input adapter on demand
-    /// instead of being counted on every scanned character. Seekable adapters
-    /// know how much input they consumed and can revisit it, so
-    /// chars_read_total is the adapter's read count (minus a pending unget),
-    /// and line and column are recomputed from the consumed input only when
-    /// get_position() is called (errors). Counting per character kept two
-    /// increments and a newline check in the hot path of every get().
-    static constexpr bool lazy_position = lazy_token_string;
-
     /// whether a simulated unget can be passed on to the input adapter, which
     /// then leaves the character in the input; see
     /// input_adapter_supports_lookahead
@@ -11110,9 +11074,7 @@ class lexer : public lexer_base<BasicJsonType>
     /// whether string scanning may bulk-consume runs of ordinary characters
     /// directly from a contiguous input buffer (SWAR fast path). This requires
     /// the token to be reconstructible lazily (lazy_token_string), so bypassing
-    /// the per-character capture in get() cannot lose error diagnostics. It
-    /// also implies lazy_position, so the bulk paths need not advance the
-    /// position counters.
+    /// the per-character capture in get() cannot lose error diagnostics.
     static constexpr bool bulk_scan =
         lazy_token_string
         && input_adapter_supports_bulk_scan<InputAdapterType>(is_detected<detect_supports_bulk_scan, InputAdapterType> {});
@@ -11140,13 +11102,13 @@ class lexer : public lexer_base<BasicJsonType>
 
     /// contiguous input: try to decode the 4 hex digits following `\\u`
     /// directly from the input buffer via hex_codepoint(), instead of 4 calls
-    /// to get(). On success, advances the adapter exactly as those 4 get()
-    /// calls would (bulk_scan implies lazy_position, so there are no position
-    /// counters to advance) and leaves @a current holding the last of
+    /// to get(). On success, advances the adapter and the position counters
+    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
+    /// only the flat counters move) and leaves @a current holding the last of
     /// the 4 digits, just as the last such get() would; the codepoint is
-    /// written to @a out. Makes no state change and returns false for a
+    /// written to @a out. Makes no state change and returns false - for a
     /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
-    /// being a hex digit, so the caller falls back unchanged to the
+    /// being a hex digit - so the caller falls back unchanged to the
     /// per-character loop, which then reports the same diagnostic (stopping
     /// at the first invalid digit) as before this optimization.
     bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
@@ -11162,6 +11124,9 @@ class lexer : public lexer_base<BasicJsonType>
             return false;
         }
         ia.bulk_skip(4);
+        // a hex digit is never a newline, so only the flat counters advance
+        position.chars_read_total += 4;
+        position.chars_read_current_line += 4;
         current = char_traits<char_type>::to_int_type(raw[3]);
         out = codepoint;
         return true;
@@ -11291,6 +11256,10 @@ class lexer : public lexer_base<BasicJsonType>
         }
         token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), pos);
         ia.bulk_skip(pos);
+        // the run contains no newline (all bytes < 0x20 are treated as special),
+        // so only the flat character counters advance
+        position.chars_read_total += pos;
+        position.chars_read_current_line += pos;
     }
 
     /// streaming input: no bulk fast path
@@ -12526,6 +12495,8 @@ scan_number_done:
             if (JSON_HEDLEY_LIKELY(integer_result != token_type::uninitialized))
             {
                 ia.bulk_skip(len - 1);
+                position.chars_read_total += (len - 1);
+                position.chars_read_current_line += (len - 1);
                 return integer_result;
             }
             // The value does not fit an integer, so this token converts as a
@@ -12542,6 +12513,8 @@ scan_number_done:
         decimal_point_position = dot_index;
 
         ia.bulk_skip(len - 1);
+        position.chars_read_total += (len - 1);
+        position.chars_read_current_line += (len - 1);
 
         return convert_number(number_type, mantissa_end);
     }
@@ -12592,7 +12565,7 @@ scan_number_done:
 
 #if JSON_DIAGNOSTIC_POSITIONS
         // the first character of the token has already been read, hence the -1
-        token_start_position = get_chars_read_total() - 1;
+        token_start_position = position.chars_read_total - 1;
 #endif
 
         note_token_start(std::integral_constant<bool, lazy_token_string> {});
@@ -12645,15 +12618,6 @@ scan_number_done:
     /// per-character position counters (line-count-on-'\n' bookkeeping is
     /// handled afterwards, in track_after_read(), once `current` is known)
     void advance_position() noexcept
-    {
-        advance_position_impl(std::integral_constant<bool, lazy_position> {});
-    }
-
-    /// seekable adapter: the position is derived from the adapter on demand
-    void advance_position_impl(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: count the character
-    void advance_position_impl(std::false_type /*lazy*/) noexcept
     {
         ++position.chars_read_total;
         ++position.chars_read_current_line;
@@ -12667,16 +12631,7 @@ scan_number_done:
         // seekable adapters reconstruct the token lazily on error (see
         // get_token_string), so the eager per-character copy is skipped
         capture_char(std::integral_constant<bool, lazy_token_string> {});
-        track_newline(std::integral_constant<bool, lazy_position> {});
-        return current;
-    }
 
-    /// seekable adapter: lines are counted on demand in get_position()
-    void track_newline(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: start a new line after reading a newline
-    void track_newline(std::false_type /*lazy*/) noexcept
-    {
         if (current == '\n')
         {
             ++position.lines_read;
@@ -12685,6 +12640,8 @@ scan_number_done:
             chars_read_before_newline = position.chars_read_current_line;
             position.chars_read_current_line = 0;
         }
+
+        return current;
     }
 
     /*!
@@ -12728,22 +12685,12 @@ scan_number_done:
     We implement unget by setting variable next_unget to true. The input is not
     changed - we just simulate ungetting by modifying chars_read_total,
     chars_read_current_line, and token_string. The next call to get() will
-    behave as if the unget character is read again. With lazy_position, the
-    pending next_unget is all get_chars_read_total() needs.
+    behave as if the unget character is read again.
     */
     void unget()
     {
         next_unget = true;
-        unget_position(std::integral_constant<bool, lazy_position> {});
-        uncapture_char(std::integral_constant<bool, lazy_token_string> {});
-    }
 
-    /// seekable adapter: get_chars_read_total() accounts for next_unget
-    void unget_position(std::true_type /*lazy*/) const noexcept {}
-
-    /// streaming adapter: step the counters back over the ungotten character
-    void unget_position(std::false_type /*lazy*/) noexcept
-    {
         --position.chars_read_total;
 
         // in case we "unget" a newline, we have to also decrement the lines_read
@@ -12766,6 +12713,8 @@ scan_number_done:
         {
             --position.chars_read_current_line;
         }
+
+        uncapture_char(std::integral_constant<bool, lazy_token_string> {});
     }
 
     /// adapter without lookahead: nothing to do (see release_lookahead)
@@ -12836,21 +12785,10 @@ scan_number_done:
     // diagnostics
     /////////////////////
 
-    /*!
-    @brief return the number of characters read so far
-
-    Unlike get_position(), this is O(1) for all adapters, so it may be called
-    for every value (JSON_DIAGNOSTIC_POSITIONS).
-    */
-    std::size_t get_chars_read_total() const noexcept
-    {
-        return get_chars_read_total_impl(std::integral_constant<bool, lazy_position> {});
-    }
-
     /// return position of last read token
-    position_t get_position() const
+    constexpr position_t get_position() const noexcept
     {
-        return get_position_impl(std::integral_constant<bool, lazy_position> {});
+        return position;
     }
 
     /*!
@@ -12887,43 +12825,6 @@ scan_number_done:
     }
 #endif
 
-  private:
-    /// seekable adapter: every get() either read from the adapter (including
-    /// reads at EOF, which get() counts as characters as well) or replayed an
-    /// ungotten character, so the count is the adapter's read count minus a
-    /// still pending unget
-    std::size_t get_chars_read_total_impl(std::true_type /*lazy*/) const noexcept
-    {
-        return ia.get_read_count() - (next_unget ? 1u : 0u);
-    }
-
-    /// streaming adapter: the counter is maintained by get() and unget()
-    std::size_t get_chars_read_total_impl(std::false_type /*lazy*/) const noexcept
-    {
-        return position.chars_read_total;
-    }
-
-    /// seekable adapter: count the lines in the consumed input; O(input read
-    /// so far), but only called on errors
-    position_t get_position_impl(std::true_type /*lazy*/) const
-    {
-        position_t result;
-        result.chars_read_total = get_chars_read_total();
-        // reads at EOF count as characters but are not part of the input
-        const std::size_t consumed = (std::min)(result.chars_read_total, ia.get_consumed_count());
-        std::size_t line_start = 0;
-        result.lines_read = ia.count_consumed_lines(consumed, line_start);
-        result.chars_read_current_line = result.chars_read_total - line_start;
-        return result;
-    }
-
-    /// streaming adapter: the position is maintained by get() and unget()
-    position_t get_position_impl(std::false_type /*lazy*/) const noexcept
-    {
-        return position;
-    }
-
-  public:
     /// seekable adapter: rebuild the last read token from the input on demand
     const std::vector<char_type>& collect_token_chars(std::vector<char_type>& out, std::true_type /*lazy*/) const
     {
@@ -13031,57 +12932,15 @@ scan_number_done:
         // into one that reloads the pointer from memory every character
         do
         {
-            if (current == '\n')
-            {
-                skip_indentation(std::integral_constant<bool, bulk_scan> {});
-            }
             get_ignoring_pending_unget();
         }
         while (current_is_whitespace());
     }
 
-    /*!
-    @brief contiguous input: skip the space indentation that follows a newline
-           8 bytes at a time
-
-    Pretty-printed JSON indents every line with a run of spaces, which the loop
-    in skip_whitespace() would otherwise read one character at a time. The
-    spaces are skipped 8 bytes at a time; the last 7 bytes of the input and any
-    other whitespace are left to that loop. Skipping bypasses get(), which is
-    fine because bulk_scan implies lazy_position: the position is derived from
-    the adapter, not counted per character.
-    */
-    void skip_indentation(std::true_type /*bulk*/)
-    {
-        JSON_ASSERT(!next_unget);
-        const std::size_t remaining = ia.bulk_remaining();
-        if (remaining < 8)
-        {
-            return;
-        }
-        const char* const data = reinterpret_cast<const char*>(ia.bulk_data());
-        std::size_t pos = 0;
-        for (; pos + 8 <= remaining; pos += 8)
-        {
-            // little-endian, so the first byte is the lowest
-            const std::uint64_t non_space = read_eight_bytes(data + pos) ^ 0x2020202020202020ull;
-            if (non_space != 0)
-            {
-                // skip the spaces before the first other byte of this word
-                pos += static_cast<std::size_t>(count_trailing_zeros(non_space)) / 8;
-                break;
-            }
-        }
-        ia.bulk_skip(pos);
-    }
-
-    /// streaming input: no bulk fast path
-    void skip_indentation(std::false_type /*bulk*/) const noexcept {}
-
     token_type scan()
     {
         // initially, skip the BOM
-        if (get_chars_read_total() == 0 && !skip_bom())
+        if (position.chars_read_total == 0 && !skip_bom())
         {
             error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
             return token_type::parse_error;
@@ -13108,7 +12967,7 @@ scan_number_done:
     token_type scan_expecting(token_type expected_type)
     {
         JSON_ASSERT(expected_type == token_type::name_separator || expected_type == token_type::value_separator);
-        JSON_ASSERT(get_chars_read_total() > 0);
+        JSON_ASSERT(position.chars_read_total > 0);
         const char_int_type expected_char = static_cast<unsigned char>((expected_type == token_type::name_separator) ? ':' : ',');
         skip_whitespace();
         if (JSON_HEDLEY_LIKELY(current == expected_char))
@@ -13462,7 +13321,7 @@ struct diagnostic_positions
         {
             // Lexer has read the first character of the container, so
             // subtract 1 from the position to get the correct start position.
-            v.start_position = lexer->get_chars_read_total() - 1;
+            v.start_position = lexer->get_position() - 1;
         }
     }
 
@@ -13476,7 +13335,7 @@ struct diagnostic_positions
         if (lexer)
         {
             // Lexer's position is past the closing brace or bracket, so set that as the end position.
-            v.end_position = lexer->get_chars_read_total();
+            v.end_position = lexer->get_position();
         }
     }
 
@@ -13492,7 +13351,7 @@ struct diagnostic_positions
             // Lexer has read past the current field value, so set the end position to the current position.
             // The start position will be set below based on the length of the string representation
             // of the value.
-            v.end_position = lexer->get_chars_read_total();
+            v.end_position = lexer->get_position();
 
             switch (v.type())
             {
@@ -19335,7 +19194,7 @@ class parser
                     }
                     case token_type::end_of_input:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_chars_read_total() == 1))
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                         {
                             return syntax_error(*sax, "attempting to parse an empty input; check that your input string or stream contains the expected JSON");
                         }
@@ -19485,10 +19344,8 @@ class parser
     {
         // MSVC 2015 reports C4100 (unreferenced parameter) when SAX::parse_error is static
         static_cast<void>(sax);
-        // computing the position is O(input read so far) for seekable input
-        const position_t position = m_lexer.get_position();
-        return sax.parse_error(position, m_lexer.get_token_string(),
-                               parse_error::create(exception_id::syntax_error, position, message, nullptr));
+        return sax.parse_error(m_lexer.get_position(), m_lexer.get_token_string(),
+                               parse_error::create(exception_id::syntax_error, m_lexer.get_position(), message, nullptr));
     }
 
     std::string exception_message(const token_type expected, const std::string& context)
@@ -22104,9 +21961,9 @@ class json_ref
 
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
-// IWYU pragma: export
+
 // #include <nlohmann/detail/macro_scope.hpp>
-// IWYU pragma: export
+
 // #include <nlohmann/detail/meta/detected.hpp>
 
 // #include <nlohmann/detail/string_concat.hpp>
@@ -29098,7 +28955,7 @@ NLOHMANN_JSON_NAMESPACE_END
 // #include <nlohmann/detail/value_t.hpp>
 
 // #include <nlohmann/json_fwd.hpp>
-// IWYU pragma: export
+
 // #include <nlohmann/ordered_map.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -36870,176 +36727,6 @@ public:
     }
 
   public:
-    /// @brief creates a diff as a JSON Merge Patch
-    /// @sa https://json.nlohmann.me/api/basic_json/merge_diff/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    static basic_json merge_diff(const basic_json& source, const basic_json& target)
-    {
-        // unless both are objects, the patch is the target itself
-        if (!source.is_object() || !target.is_object())
-        {
-            return target;
-        }
-
-        return merge_diff_recursively(source, target, 0);
-    }
-
-  private:
-    /// @brief two objects @ref merge_diff_iteratively is diffing
-    struct merge_diff_frame
-    {
-        merge_diff_frame(const basic_json* source_, const basic_json* target_)
-            : source(source_), target(target_), member(source_->cbegin()), patch(value_t::object)
-        {}
-
-        // declared for GCC's -Weffc++, as in diff_frame
-        merge_diff_frame(const merge_diff_frame&) = default;
-        merge_diff_frame(merge_diff_frame&&) = default;
-        merge_diff_frame& operator=(const merge_diff_frame&) = default;
-        merge_diff_frame& operator=(merge_diff_frame&&) = default;
-        ~merge_diff_frame() = default;
-
-        /// the objects being diffed
-        const basic_json* source;
-        const basic_json* target;
-        /// the member of source being diffed; advanced once it is done
-        const_iterator member;
-        /// the patch for the members of source diffed so far
-        basic_json patch;
-    };
-
-    /// @brief add the members of object @a target that @a source does not
-    ///        have to the merge patch @a result
-    static void merge_diff_added_members(basic_json& result, const basic_json& source, const basic_json& target)
-    {
-        for (auto it = target.begin(); it != target.end(); ++it)
-        {
-            auto itf = source.find(it.key());
-            if (itf == source.end())
-            {
-                result[it.key()] = it.value();
-            }
-        }
-    }
-
-    /*!
-    @brief @ref merge_diff of two objects at nesting level @a depth
-
-    Diffing two nested objects calls this function again, once per nesting
-    level, so values nested deeply enough would exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    merge_diff_iteratively diffs what is left without the call stack.
-    */
-    static basic_json merge_diff_recursively(const basic_json& source, const basic_json& target, const std::size_t depth)
-    {
-        JSON_ASSERT(source.is_object() && target.is_object());
-
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            return merge_diff_iteratively(source, target);
-        }
-
-        basic_json result(value_t::object);
-
-        for (auto it = source.begin(); it != source.end(); ++it)
-        {
-            auto itf = target.find(it.key());
-            if (itf != target.end())
-            {
-                if (it.value().is_object() && itf.value().is_object())
-                {
-                    auto diff = merge_diff_recursively(it.value(), itf.value(), depth + 1);
-                    if (!diff.empty())
-                    {
-                        result[it.key()] = std::move(diff);
-                    }
-                }
-                else if (it.value() != itf.value())
-                {
-                    result[it.key()] = itf.value();
-                }
-            }
-            else
-            {
-                result[it.key()] = value_t::null;
-            }
-        }
-
-        merge_diff_added_members(result, source, target);
-        return result;
-    }
-
-    /*!
-    @brief @ref merge_diff of two objects without the call stack
-
-    Produces the same patch as @ref merge_diff_recursively, keeping the objects
-    being diffed on an explicit stack instead of descending into them. Two
-    nested objects are still diffed completely before the next member, so the
-    patch has its members in the same order as in the recursive version. Only
-    reached for objects nested more deeply than @ref
-    detail::recursion_depth_limit.
-    */
-    static basic_json merge_diff_iteratively(const basic_json& source, const basic_json& target)
-    {
-        // the patch of source and target, set once their frame is popped
-        basic_json result;
-        std::vector<merge_diff_frame> stack;
-        stack.emplace_back(&source, &target);
-        while (!stack.empty())
-        {
-            // the frame's members are copied out and it is changed through
-            // stack.back(): pushing a frame for nested objects or popping
-            // this one would invalidate a reference to it
-            const basic_json* const s = stack.back().source;
-            const basic_json* const t = stack.back().target;
-            const const_iterator it = stack.back().member;
-
-            if (it != s->cend())
-            {
-                const const_iterator itf = t->find(it.key());
-                if (itf != t->cend())
-                {
-                    if (it.value().is_object() && itf.value().is_object())
-                    {
-                        // member is advanced once their patch is under its key
-                        stack.emplace_back(&it.value(), &itf.value());
-                        continue;
-                    }
-                    if (it.value() != itf.value())
-                    {
-                        stack.back().patch[it.key()] = itf.value();
-                    }
-                }
-                else
-                {
-                    stack.back().patch[it.key()] = value_t::null;
-                }
-                ++stack.back().member;
-                continue;
-            }
-
-            merge_diff_added_members(stack.back().patch, *s, *t);
-
-            // these objects are done: continue with the ones they are in
-            basic_json patch = std::move(stack.back().patch);
-            stack.pop_back();
-            if (stack.empty())
-            {
-                result = std::move(patch);
-            }
-            else
-            {
-                if (!patch.empty())
-                {
-                    stack.back().patch[stack.back().member.key()] = std::move(patch);
-                }
-                ++stack.back().member;
-            }
-        }
-        return result;
-    }
-
     /// @}
 };
 
@@ -37511,7 +37198,7 @@ NLOHMANN_JSON_NAMESPACE_END
 #undef NLOHMANN_JSON_LITERAL_OPERATOR
 
 #endif  // INCLUDE_NLOHMANN_JSON_LITERALS_HPP_
-// IWYU pragma: export
+
 #endif
 
 #endif  // INCLUDE_NLOHMANN_JSON_HPP_

tests/iwyu_consumer/conversions.cpp

@@ -1,62 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// See values.cpp: the conversion macros and nlohmann::adl_serializer must be available through
-// <nlohmann/json.hpp> alone. NLOHMANN_JSON_SERIALIZE_ENUM (from the same header as
-// NLOHMANN_DEFINE_TYPE_INTRUSIVE) is left out: IWYU attributes the basic_json comparison in its
-// expansion to an unrelated standard header, the ambiguity described for json.hpp in cmake/ci.cmake.
-
-#include <string>
-
-#include <nlohmann/json.hpp>
-
-namespace ns
-{
-struct person
-{
-    std::string name;
-    int age;
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE(person, name, age)
-};
-
-struct legacy
-{
-    int value;
-};
-} // namespace ns
-
-namespace nlohmann
-{
-template<>
-struct adl_serializer<ns::legacy>
-{
-    static void to_json(json& j, const ns::legacy& l)
-    {
-        j = l.value;
-    }
-
-    static void from_json(const json& j, ns::legacy& l)
-    {
-        l.value = j.get<int>();
-    }
-};
-} // namespace nlohmann
-
-int main()
-{
-    ns::person ada;
-    ada.name = "Ada";
-    ada.age = 36;
-    ns::legacy one;
-    one.value = 1;
-
-    const nlohmann::json j = ada;
-    const auto p = j.get<ns::person>();
-    const auto l = nlohmann::json(one).get<ns::legacy>();
-    return p.age - 36 + l.value - 1;
-}

tests/iwyu_consumer/literals.cpp

@@ -1,19 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// See values.cpp: the user-defined literals must be available through <nlohmann/json.hpp> alone.
-
-#include <nlohmann/json.hpp>
-
-using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-
-int main()
-{
-    const auto j = R"({"a": [1, 2]})"_json;
-    return j.at("/a/1"_json_pointer).get<int>() - 2;
-}

tests/iwyu_consumer/values.cpp

@@ -1,30 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// Uses the library the way a client does, including only <nlohmann/json.hpp>. ci_single_binaries
-// runs include-what-you-use and clang-tidy's misc-include-cleaner on this file and fails if either
-// asks for another nlohmann header, which would mean json.hpp does not export it (issue #5812).
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    // brace initialization (nlohmann::json, detail::json_ref)
-    nlohmann::json j = {{"pi", 3.141}, {"list", {1, 0, 2}}};
-    const nlohmann::ordered_json o = {{"b", 1}, {"a", 2}};
-
-    j["parsed"] = nlohmann::json::parse(R"({"happy": true})");
-    j["binary"] = nlohmann::json::binary(std::vector<std::uint8_t> {0xCA, 0xFE}, 42);
-
-    const std::string s = j.dump() + o.dump();
-    return s.empty() ? 1 : 0;
-}

tests/src/unit-class_lexer.cpp

@@ -1183,10 +1183,6 @@ TEST_CASE("Eisel-Lemire float conversion")
             const int k = i % 64;
             const std::uint64_t x = (std::uint64_t{1} << k) | (a & ((std::uint64_t{1} << k) - 1));
             CHECK(nlohmann::detail::count_leading_zeros(x) == 63 - k);
-
-            // the mirror image: bit k set, arbitrary bits above it
-            const std::uint64_t y = (std::uint64_t{1} << k) | (k == 63 ? 0 : (a << (k + 1)));
-            CHECK(nlohmann::detail::count_trailing_zeros(y) == k);
         }
     }
 

tests/src/unit-custom-binary-type.cpp

@@ -8,13 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DISABLE_ENUM_SERIALIZATION was enabled on the command
-// line before including json.hpp, which #undefs it; std::byte is an enum, so
-// converting std::vector<std::byte> needs enum serialization
-#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
-    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
-#endif
-
 #include <nlohmann/json.hpp>
 
 #include <cstdint>
@@ -92,53 +85,3 @@ TEST_CASE("binary type whose value type is not std::uint8_t")
     }
 #endif
 }
-
-#ifdef JSON_HAS_CPP_17
-// moved from unit-regression3.cpp, so that file does not instantiate a second
-// basic_json specialization (MinGW section limit, see windows.yml)
-TEST_CASE("std::vector<std::byte> as binary type")
-{
-    SECTION("issue #4804: from_cbor incompatible with std::vector<std::byte> as binary_t")
-    {
-        const std::vector<std::uint8_t> data = {0x80};
-        const auto decoded = byte_binary_json::from_cbor(data);
-        CHECK((decoded == byte_binary_json::array()));
-    }
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
-    {
-        // Test that assigning a custom BinaryType directly creates a binary value, not an array
-        const std::vector<std::byte> original{std::byte{1}, std::byte{2}, std::byte{3}};
-        const byte_binary_json j = original;
-        CHECK(j.is_binary());
-        CHECK(!j.is_array());
-
-        // Test round-tripping: extracting the binary value back as the custom container type
-        const auto extracted = j.get<std::vector<std::byte>>();
-        CHECK(extracted == original);
-
-        // Test that the default json alias behavior is unchanged: std::vector<uint8_t> -> array
-        const nlohmann::json default_json = std::vector<std::uint8_t> {1, 2, 3};
-        CHECK(default_json.is_array());
-        CHECK(!default_json.is_binary());
-    }
-
-    SECTION("discussion #4209 - custom BinaryType extraction from parsed array")
-    {
-        // Test that extracting a custom BinaryType from a parsed JSON array still works
-        // (not just from a binary-typed node)
-        const auto j = byte_binary_json::parse("[1,2,3]");
-        CHECK(j.is_array());
-        CHECK(!j.is_binary());
-
-        // Extracting as custom BinaryType should work from arrays
-        const auto extracted = j.get<std::vector<std::byte>>();
-        CHECK(extracted.size() == 3);
-        CHECK(extracted[0] == std::byte{1});
-        CHECK(extracted[1] == std::byte{2});
-        CHECK(extracted[2] == std::byte{3});
-    }
-#endif
-}
-#endif

tests/src/unit-deserialization.cpp

@@ -35,7 +35,6 @@ using nlohmann::json;
 #include <sstream>
 #include <string>
 #include <valarray>
-#include <vector>
 
 #include "sax_event_loggers.hpp"
 
@@ -1251,139 +1250,3 @@ TEST_CASE_TEMPLATE("deserialization of different character types (UTF-32)", T, c
     CHECK(json::sax_parse(v, &l));
     CHECK(l.events.size() == 1);
 }
-
-namespace
-{
-// records the position and message of a parse error; reporting the error via
-// SAX does not throw, so the test also runs with JSON_NOEXCEPTION
-struct SaxErrorRecorder : public SaxEventLogger
-{
-    bool parse_error(std::size_t position, const std::string& /*last_token*/, const json::exception& ex) override
-    {
-        error = std::to_string(position) + " " + ex.what();
-        return false;
-    }
-
-    std::string error {}; // NOLINT(readability-redundant-member-init)
-};
-} // namespace
-
-TEST_CASE("parse error positions are the same for contiguous and stream input")
-{
-    // contiguous input derives the position from the input on error, stream
-    // input counts it while reading (see lexer::lazy_position); the cases
-    // cover newlines before the error, ungetting a newline after a number,
-    // newlines inside a string, a comment, and reads at the end of input
-    struct test_case
-    {
-        std::string input;
-        std::size_t byte;
-        std::string message;
-    };
-    const std::vector<test_case> cases =
-    {
-        {"[\n  1,\n  2\n", 12, "[json.exception.parse_error.101] parse error at line 4, column 1: syntax error while parsing array - unexpected end of input; expected ']'"},
-        {"[1\n,2,\n]", 8, "[json.exception.parse_error.101] parse error at line 3, column 1: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal"},
-        {"[1\n x]", 5, "[json.exception.parse_error.101] parse error at line 2, column 2: syntax error while parsing array - invalid literal; last read: '1<U+000A> x'; expected ']'"},
-        {"1\n2", 3, "[json.exception.parse_error.101] parse error at line 2, column 1: syntax error while parsing value - unexpected number literal; expected end of input"},
-        {
-            "{\"a\":\n\"b\nc\"}", 9, R"([json.exception.parse_error.101] parse error at line 3, column 0: syntax error while parsing value - invalid string: control character U+000A (LF) must be escaped to \u000A or \n; last read: '"b<U+000A>')"
-        },
-        {"/* a\n b */\n x", 13, "[json.exception.parse_error.101] parse error at line 3, column 2: syntax error while parsing value - invalid literal; last read: '/* a<U+000A> b */<U+000A> x'"},
-        {"\n\n", 3, "[json.exception.parse_error.101] parse error at line 3, column 1: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal"},
-        {"[\"a\",\n 1e\n]", 10, "[json.exception.parse_error.101] parse error at line 3, column 0: syntax error while parsing value - invalid number; expected '+', '-', or digit after exponent; last read: '1e<U+000A>'"},
-        {"[tru\n]", 5, "[json.exception.parse_error.101] parse error at line 2, column 0: syntax error while parsing value - invalid literal; last read: '[tru<U+000A>'"},
-    };
-
-    for (const auto& c : cases)
-    {
-        CAPTURE(c.input)
-        const std::string expected = std::to_string(c.byte) + " " + c.message;
-
-        SaxErrorRecorder string_sax;
-        CHECK_FALSE(json::sax_parse(c.input, &string_sax, json::input_format_t::json, true, true));
-        CHECK(string_sax.error == expected);
-
-        SaxErrorRecorder pointer_sax;
-        CHECK_FALSE(json::sax_parse(c.input.data(), c.input.data() + c.input.size(), &pointer_sax, json::input_format_t::json, true, true));
-        CHECK(pointer_sax.error == expected);
-
-        std::istringstream is(c.input);
-        SaxErrorRecorder stream_sax;
-        CHECK_FALSE(json::sax_parse(is, &stream_sax, json::input_format_t::json, true, true));
-        CHECK(stream_sax.error == expected);
-    }
-}
-
-#if !defined(JSON_NOEXCEPTION)
-TEST_CASE("indentation runs of every length around the 8-byte skip")
-{
-    // contiguous input skips the spaces after a newline 8 bytes at a time (see
-    // lexer::skip_indentation), stream input reads them one by one; results,
-    // byte offsets, and messages must be the same for runs that end anywhere
-    // relative to a word boundary, including at the end of the input
-    const auto parse_result = [](const std::string & input, bool contiguous)
-    {
-        try
-        {
-            if (contiguous)
-            {
-                return json::parse(input.data(), input.data() + input.size(), nullptr, true, true).dump();
-            }
-            std::istringstream is(input);
-            return json::parse(is, nullptr, true, true).dump();
-        }
-        catch (const json::parse_error& e)
-        {
-            return std::to_string(e.byte).append(" ").append(e.what());
-        }
-    };
-
-    // replace every '~' in a pattern by an indentation run
-    const auto indented = [](const std::string & pattern, const std::string & indent)
-    {
-        std::string result;
-        for (const char c : pattern)
-        {
-            if (c == '~')
-            {
-                result += indent;
-            }
-            else
-            {
-                result += c;
-            }
-        }
-        return result;
-    };
-
-    const std::vector<std::string> patterns =
-    {
-        "[\n~1,\n~2\n]",
-        "[\n~1,\n~x]",
-        "[\n~1,\n~",
-        "1\n~",
-        "[\n~\t1,\n~\r\n~2]",
-        "[\n~/* c */ 1]",
-        "[\n~1\n~2]",
-    };
-
-    for (std::size_t n = 0; n <= 33; ++n)
-    {
-        const std::string indent(n, ' ');
-        for (const auto& pattern : patterns)
-        {
-            const std::string input = indented(pattern, indent);
-            CAPTURE(n)
-            CAPTURE(input)
-            const std::string expected = parse_result(input, false);
-            CHECK(parse_result(input, true) == expected);
-            CHECK(json::accept(input.data(), input.data() + input.size(), true) == json::accept(input, true));
-        }
-    }
-
-    // and against fixed expectations, in case both paths broke the same way
-    CHECK(parse_result(indented("[\n~x]", std::string(16, ' ')), true) == "19 [json.exception.parse_error.101] parse error at line 2, column 17: syntax error while parsing value - invalid literal; last read: '[<U+000A>                x'");
-    CHECK(parse_result(indented("[\n~1]", std::string(17, ' ')), true) == "[1]");
-}
-#endif

tests/src/unit-diagnostics.cpp

@@ -567,9 +567,9 @@ TEST_CASE("Regression tests for extended diagnostics")
     }
 }
 
-TEST_CASE("Better diagnostics past the descent bound of update(), merge_patch() and merge_diff()")
+TEST_CASE("Better diagnostics past the descent bound of update() and merge_patch()")
 {
-    // All three handle objects nested more than detail::recursion_depth_limit()
+    // Both merge objects nested more than detail::recursion_depth_limit()
     // (128) levels deep without recursing; the values they add or replace
     // there must still know their parents.
     // The values are built rather than parsed, so that the expected messages
@@ -615,19 +615,4 @@ TEST_CASE("Better diagnostics past the descent bound of update(), merge_patch()
         CHECK_THROWS_WITH_AS(p->at("x").at(0), expected_x.c_str(), json::type_error);
         CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
     }
-
-    SECTION("merge_diff()")
-    {
-        // target and patch differ only in their innermost members, so the
-        // diff of the two is nested as deeply: {"a": ... {"x": null, "y": 2}}
-        const json diff = json::merge_diff(target, patch); // NOLINT(readability-suspicious-call-argument)
-
-        const json* p = &diff;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK(p->at("x").is_null());
-        CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
-    }
 }

tests/src/unit-regression3.cpp

@@ -58,6 +58,11 @@ using ordered_json = nlohmann::ordered_json;
         #include <optional>
     #elif __has_include(<experimental/optional>)
     #endif
+
+    /////////////////////////////////////////////////////////////////////
+    // for #4804
+    /////////////////////////////////////////////////////////////////////
+    using json_4804 = nlohmann::json::with_binary_t<std::vector<std::byte>>;
 #endif
 
 #ifdef JSON_HAS_CPP_20
@@ -453,6 +458,49 @@ TEST_CASE("regression tests 3")
 #endif
 
 #ifdef JSON_HAS_CPP_17
+    SECTION("issue #4804: from_cbor incompatible with std::vector<std::byte> as binary_t")
+    {
+        const std::vector<std::uint8_t> data = {0x80};
+        const auto decoded = json_4804::from_cbor(data);
+        CHECK((decoded == json_4804::array()));
+    }
+
+#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
+    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
+    {
+        // Test that assigning a custom BinaryType directly creates a binary value, not an array
+        const std::vector<std::byte> original{std::byte{1}, std::byte{2}, std::byte{3}};
+        const json_4804 j = original;
+        CHECK(j.is_binary());
+        CHECK(!j.is_array());
+
+        // Test round-tripping: extracting the binary value back as the custom container type
+        const auto extracted = j.get<std::vector<std::byte>>();
+        CHECK(extracted == original);
+
+        // Test that the default json alias behavior is unchanged: std::vector<uint8_t> -> array
+        const json default_json = std::vector<std::uint8_t> {1, 2, 3};
+        CHECK(default_json.is_array());
+        CHECK(!default_json.is_binary());
+    }
+
+    SECTION("discussion #4209 - custom BinaryType extraction from parsed array")
+    {
+        // Test that extracting a custom BinaryType from a parsed JSON array still works
+        // (not just from a binary-typed node)
+        const auto j = json_4804::parse("[1,2,3]");
+        CHECK(j.is_array());
+        CHECK(!j.is_binary());
+
+        // Extracting as custom BinaryType should work from arrays
+        const auto extracted = j.get<std::vector<std::byte>>();
+        CHECK(extracted.size() == 3);
+        CHECK(extracted[0] == std::byte{1});
+        CHECK(extracted[1] == std::byte{2});
+        CHECK(extracted[2] == std::byte{3});
+    }
+#endif
+
     SECTION("issue #5046 - implicit conversion of return json to std::optional no longer implicit")
     {
         const json jval{};