Assert on missing array indices in const operator[] and document the JSON pointer case

The const operator[] overloads are unchecked by design, and a missing key
or index is undefined behavior. The key overload guards this with a
runtime assertion, but the index overload did not, although the element
access documentation says an assertion fires in both cases. The const
JSON pointer overload inherits both through json_pointer::get_unchecked(),
so a pointer to a missing array index read out of bounds even in debug
builds, and its documentation promised out_of_range.404 for any pointer
that cannot be resolved.

Add JSON_ASSERT(idx < size()) to const operator[](size_type), which also
covers the index leg of the const JSON pointer overload. Document the
undefined behavior for the const JSON pointer overload in operator[].md
and in the runtime assertions page. Release builds are unchanged.

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

.github/workflows/ubuntu.yml

@@ -31,45 +31,6 @@ jobs:
       - name: Build
         run: cmake --build build --target ci_test_gcc
 
-  ci_meson_install:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
-      - name: Install Meson
-        run: pip install meson
-      - name: Install with Meson
-        run: |
-          meson setup build-meson --prefix=${{ github.workspace }}/install
-          meson install -C build-meson
-      - name: Use the installed package with find_package
-        run: |
-          cmake -S tests/cmake_import/project -B build-import -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install
-          cmake --build build-import
-      - name: Install with Meson and non-default options
-        run: |
-          meson setup build-meson-options --prefix=${{ github.workspace }}/install-options -DMultipleHeaders=true -DDiagnostics=true -DGlobalUDLs=false
-          meson install -C build-meson-options
-      - name: Check that the options reach the installed files
-        run: |
-          test -d install-options/include/nlohmann/detail
-          cflags=$(PKG_CONFIG_PATH=${{ github.workspace }}/install-options/share/pkgconfig pkg-config --cflags nlohmann_json)
-          echo "$cflags"
-          echo "$cflags" | grep -q -- '-DJSON_DIAGNOSTICS=1'
-          echo "$cflags" | grep -q -- '-DJSON_USE_GLOBAL_UDLS=0'
-          grep -q 'JSON_USE_GLOBAL_UDLS=0;JSON_DIAGNOSTICS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
-          cmake -S tests/cmake_import/project -B build-import-options -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-options
-          cmake --build build-import-options
-      - name: Install with Meson and the include directory outside the prefix
-        run: |
-          meson setup build-meson-split --prefix=${{ github.workspace }}/install-split --includedir=${{ github.workspace }}/install-split-dev/include
-          meson install -C build-meson-split
-          cmake -S tests/cmake_import/project -B build-import-split -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-split
-          cmake --build build-import-split
-
   ci_infer:
     runs-on: ubuntu-latest
     steps:

CMakeLists.txt

@@ -168,30 +168,7 @@ if (MSVC)
     )
 endif()
 
-# Install a pkg-config file, so other tools can find this. It carries the same
+# Install a pkg-config file, so other tools can find this.
-# compile definitions as the target above.
-set(NLOHMANN_JSON_PKGCONFIG_CFLAGS "")
-if (NOT JSON_GlobalUDLs)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_GLOBAL_UDLS=0")
-endif()
-if (NOT JSON_ImplicitConversions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_IMPLICIT_CONVERSIONS=0")
-endif()
-if (JSON_DisableEnumSerialization)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_ENUM_SERIALIZATION=1")
-endif()
-if (JSON_Diagnostics)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTICS=1")
-endif()
-if (JSON_Diagnostic_Positions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTIC_POSITIONS=1")
-endif()
-if (JSON_LegacyDiscardedValueComparison)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1")
-endif()
-if (JSON_StrictNulHandling)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_NUL_HANDLING=1")
-endif()
 configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"

FILES.md

@@ -260,29 +260,9 @@ make BUILD.bazel
 
 The "Check amalgamation" workflow fails if the file is out of date.
 
-### `meson.build` and `meson_options.txt`
+### `meson.build`
 
-Meson build definitions suitable for use as a subproject ("wrap" in Meson terminology).
+The build definition for the [Meson](https://mesonbuild.com) build system.
-
-Projects wishing to use the wrap can execute:
-```sh
-meson wrap install nlohmann_json
-```
-
-Which allows Meson to build from source when a system provided dependency isn't available.
-
-To build directly:
-```sh
-meson setup builddir
-ninja -C builddir
-```
-
-`meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
-`-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`.
-
-When installing, `meson.build` installs the headers, a pkg-config file, and the CMake package config files, so that
-`find_package(nlohmann_json)` works. As Meson cannot generate `nlohmann_jsonTargets.cmake` itself, it is created from
-the template `cmake/nlohmann_jsonTargets.cmake.in`, which is only used by Meson.
 
 ### `Package.swift`
 

Makefile

@@ -222,7 +222,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
 
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz

cmake/nlohmann_jsonTargets.cmake.in

@@ -1,38 +0,0 @@
-# Imported target for installations made with Meson (see meson.build).
-#
-# CMake installations generate this file with install(EXPORT ...). Meson cannot
-# do that, but as the library is header-only, the target only needs an include
-# directory, the C++ standard, and the compile definitions of the options that
-# differ from their defaults. Paths are computed relative to this file so that
-# the installation can be relocated (e.g., into a sysroot), unless includedir or
-# datadir is outside the prefix.
-
-if(TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
-    return()
-endif()
-
-get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_CONFIG_TO_PREFIX@" ABSOLUTE)
-
-add_library(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
-set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "@NLOHMANN_JSON_INCLUDE_DIR@"
-)
-if(CMAKE_VERSION VERSION_LESS 3.8)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_range_for
-    )
-else()
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_std_11
-    )
-endif()
-
-set(_NLOHMANN_JSON_COMPILE_DEFINITIONS "@NLOHMANN_JSON_COMPILE_DEFINITIONS@")
-if(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "${_NLOHMANN_JSON_COMPILE_DEFINITIONS}"
-    )
-endif()
-
-unset(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-unset(_IMPORT_PREFIX)

cmake/pkg-config.pc.in

@@ -4,4 +4,4 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 Name: @PROJECT_NAME@
 Description: JSON for Modern C++
 Version: @PROJECT_VERSION@
-Cflags: -I${includedir}@NLOHMANN_JSON_PKGCONFIG_CFLAGS@
+Cflags: -I${includedir}

docs/mkdocs/docs/api/basic_json/operator[].md

@@ -86,6 +86,9 @@ Strong exception safety: if an exception occurs, the original value stays intact
     - Throws [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) if an array index in the passed
       JSON pointer `ptr` exceeds the range of `size_type` (e.g., on 32-bit platforms).
 
+    For the **const** version, an object key or array index in `ptr` that does not exist is not reported by an
+    exception, but is undefined behavior (see the notes below). Use [`at`](at.md) for checked access.
+
 ## Complexity
 
 1. Constant if `idx` is in the range of the array. Otherwise, linear in `idx - size()`.
@@ -100,9 +103,12 @@ Strong exception safety: if an exception occurs, the original value stays intact
     The following cases apply to the **const** overloads; the non-const overloads instead insert the missing element
     (see the notes below).
 
-    1. If the element at index `idx` does not exist, the behavior is undefined.
+    1. If the element at index `idx` does not exist, the behavior is undefined and is **guarded by a
+       [runtime assertion](../../features/assertions.md)**!
     2. If the element with key `key` does not exist, the behavior is undefined and is **guarded by a
        [runtime assertion](../../features/assertions.md)**!
+    3. If the JSON pointer `ptr` refers to an object key or an array index that does not exist, the behavior is
+       undefined and is **guarded by a [runtime assertion](../../features/assertions.md)**!
 
 1. The non-const version may add values: If `idx` is beyond the range of the array (i.e., `idx >= size()`), then the
    array is silently filled up with `#!json null` values to make `idx` a valid reference to the last stored element. In
@@ -257,9 +263,11 @@ Strong exception safety: if an exception occurs, the original value stays intact
 
 ## Version history
 
-1. Added in version 1.0.0.
+1. Added in version 1.0.0. A missing index in the const version is guarded by a runtime assertion since version
+   3.13.0.
 2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3)
    in version 3.11.0.
 3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
    already supported by [`at`](at.md), [`value`](value.md), [`find`](find.md), and other lookup functions.
-4. Added in version 2.0.0.
+4. Added in version 2.0.0. A missing array index in the const version is guarded by a runtime assertion since
+   version 3.13.0.

docs/mkdocs/docs/features/assertions.md

@@ -16,14 +16,15 @@ before including the `json.hpp` header.
 
 ## Function with runtime assertions
 
-### Unchecked object access to a const value
+### Unchecked access to a const value
 
-Function [`operator[]`](../api/basic_json/operator%5B%5D.md) implements unchecked access for objects. Whereas a missing
+Function [`operator[]`](../api/basic_json/operator%5B%5D.md) implements unchecked access for arrays and objects. Whereas
-key is added in the case of non-const objects, accessing a const object with a missing key is undefined behavior (think
+a missing element is added in the case of non-const values, accessing a const value with a missing object key or an
-of a dereferenced null pointer) and yields a runtime assertion.
+invalid array index is undefined behavior (think of a dereferenced null pointer) and yields a runtime assertion. This
+also applies to a [JSON pointer](json_pointer.md) that refers to a missing key or an invalid index.
 
-If you are not sure whether an element in an object exists, use checked access with the
+If you are not sure whether an element exists, use checked access with the [`at` function](../api/basic_json/at.md)
-[`at` function](../api/basic_json/at.md) or call the [`contains` function](../api/basic_json/contains.md) before.
+or call the [`contains` function](../api/basic_json/contains.md) before.
 
 See also the documentation on [element access](element_access/index.md).
 
@@ -46,7 +47,30 @@ See also the documentation on [element access](element_access/index.md).
     Output:
 
     ```
-    Assertion failed: (m_value.object->find(key) != m_value.object->end()), function operator[], file json.hpp, line 2144.
+    Assertion failed: (it != m_data.m_value.object->end()), function operator[], file json.hpp, line 28795.
+    ```
+
+??? example "Example 2: Invalid array index in a JSON pointer"
+
+    The following code will trigger an assertion at runtime:
+
+    ```cpp
+    #include <nlohmann/json.hpp>
+    
+    using json = nlohmann::json;
+    using namespace nlohmann::literals;
+    
+    int main()
+    {
+        const json j = {{"array", {1, 2, 3}}};
+        auto v = j["/array/5"_json_pointer];
+    }
+    ```
+
+    Output:
+
+    ```
+    Assertion failed: (idx < m_data.m_value.array->size()), function operator[], file json.hpp, line 28758.
     ```
 
 ### Constructing from an uninitialized iterator range

docs/mkdocs/docs/integration/package_managers.md

@@ -121,23 +121,10 @@ meson wrap install nlohmann_json
 Please see the Meson project for any issues regarding the packaging.
 
 The provided `meson.build` can also be used as an alternative to CMake for installing `nlohmann_json` system-wide in
-which case a pkg-config file and the CMake package config files are installed. To use it, have your build system require
+which case a pkg-config file is installed. To use it, have your build system require the `nlohmann_json`
-the `nlohmann_json` pkg-config dependency, or use [`find_package(nlohmann_json)`](cmake.md#external) in CMake. In Meson,
+pkg-config dependency. In Meson, it is preferred to use the
-it is preferred to use the [`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a
+[`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a subproject fallback, rather than
-subproject fallback, rather than using the subproject directly.
+using the subproject directly.
-
-The options that change the library's configuration are available in Meson as well, named like the
-[CMake options](cmake.md#cmake-options) without the `JSON_` prefix: `MultipleHeaders`, `GlobalUDLs`,
-`ImplicitConversions`, `DisableEnumSerialization`, `Diagnostics`, `Diagnostic_Positions`,
-`LegacyDiscardedValueComparison`, and `StrictNulHandling`. They have the same defaults as in CMake, except that
-`MultipleHeaders` is `false`. Set them with `-D` when setting up the build, or with the subproject name as prefix when
-the library is used as a subproject:
-
-```shell
-meson setup build -Dnlohmann_json:Diagnostics=true
-```
-
-The resulting compile definitions are part of the Meson dependency, the pkg-config file, and the CMake target.
 
 ??? example "Example: Wrap"
 

include/nlohmann/detail/json_pointer.hpp

@@ -535,6 +535,10 @@ class json_pointer
     @return const reference to the JSON value pointed to by the JSON
     pointer
 
+    @pre Every object key and array index the pointer refers to exists.
+         Like the const operator[] for keys and indices, a missing one is
+         undefined behavior, guarded by a runtime assertion.
+
     @throw parse_error.106   if an array index begins with '0'
     @throw parse_error.109   if an array index was not a number
     @throw out_of_range.402  if the array index '-' is used
@@ -549,7 +553,8 @@ class json_pointer
             {
                 case detail::value_t::object:
                 {
-                    // use unchecked object access
+                    // use unchecked object access; the const operator[]
+                    // asserts that the key exists
                     ptr = &ptr->operator[](reference_token);
                     break;
                 }
@@ -562,7 +567,8 @@ class json_pointer
                         JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
                     }
 
-                    // use unchecked array access
+                    // use unchecked array access; the const operator[]
+                    // asserts that the index exists
                     ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                     break;
                 }

include/nlohmann/json.hpp

@@ -2866,6 +2866,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         // const operator[] only works for arrays
         if (JSON_HEDLEY_LIKELY(is_array()))
         {
+            JSON_ASSERT(idx < m_data.m_value.array->size());
             return m_data.m_value.array->operator[](idx);
         }
 

meson.build

@@ -2,111 +2,23 @@ project('nlohmann_json',
     'cpp',
     version : '3.12.0',
     license : 'MIT',
-    meson_version : '>= 0.64',
-    default_options: ['cpp_std=c++11'],
 )
 
-if get_option('MultipleHeaders')
-    incdir = 'include'
-else
-    incdir = 'single_include'
-endif
-
-# The same compile definitions as the CMake target (see target_compile_definitions
-# in CMakeLists.txt): only an option that differs from its default adds one.
-json_defines = []
-if not get_option('GlobalUDLs')
-    json_defines += 'JSON_USE_GLOBAL_UDLS=0'
-endif
-if not get_option('ImplicitConversions')
-    json_defines += 'JSON_USE_IMPLICIT_CONVERSIONS=0'
-endif
-if get_option('DisableEnumSerialization')
-    json_defines += 'JSON_DISABLE_ENUM_SERIALIZATION=1'
-endif
-if get_option('Diagnostics')
-    json_defines += 'JSON_DIAGNOSTICS=1'
-endif
-if get_option('Diagnostic_Positions')
-    json_defines += 'JSON_DIAGNOSTIC_POSITIONS=1'
-endif
-if get_option('LegacyDiscardedValueComparison')
-    json_defines += 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1'
-endif
-if get_option('StrictNulHandling')
-    json_defines += 'JSON_STRICT_NUL_HANDLING=1'
-endif
-
-cpp_args = []
-foreach define : json_defines
-    cpp_args += '-D' + define
-endforeach
-
 nlohmann_json_dep = declare_dependency(
-    compile_args: cpp_args,
+    include_directories: include_directories('single_include')
-    include_directories: include_directories(incdir)
 )
-meson.override_dependency('nlohmann_json', nlohmann_json_dep)
 
-# The multi-header version under the name earlier versions of this file used
 nlohmann_json_multiple_headers = declare_dependency(
-    compile_args: cpp_args,
     include_directories: include_directories('include')
 )
 
 if not meson.is_subproject()
-    install_subdir(
+install_headers('single_include/nlohmann/json.hpp', subdir: 'nlohmann')
-        incdir / 'nlohmann',
+install_headers('single_include/nlohmann/json_fwd.hpp', subdir: 'nlohmann')
-        install_dir: get_option('includedir'),
-        install_tag: 'devel',
-    )
 
-    pkgc = import('pkgconfig')
+pkgc = import('pkgconfig')
-    pkgc.generate(name: 'nlohmann_json',
+pkgc.generate(name: 'nlohmann_json',
     version: meson.project_version(),
-        description: 'JSON for Modern C++',
+    description: 'JSON for Modern C++'
-        extra_cflags: cpp_args,
+)
-        install_dir: get_option('datadir') / 'pkgconfig',
-    )
-
-    # CMake package config files, so that find_package(nlohmann_json) works. The
-    # include directory is given relative to the config files, so that the
-    # installation can be relocated. This is not possible if includedir or datadir
-    # is an absolute path outside the prefix (e.g., with the separate outputs of
-    # Nix); then the absolute include directory is used, as CMake does.
-    fs = import('fs')
-    cmake_install_dir = get_option('datadir') / 'cmake' / meson.project_name()
-    cmake_to_prefix = []
-    if fs.is_absolute(get_option('includedir')) or fs.is_absolute(cmake_install_dir)
-        cmake_include_dir = (get_option('prefix') / get_option('includedir')).replace('\\', '/')
-    else
-        foreach component : cmake_install_dir.split('/')
-            cmake_to_prefix += '..'
-        endforeach
-        cmake_include_dir = '${_IMPORT_PREFIX}/' + get_option('includedir')
-    endif
-
-    cmake_conf = configuration_data()
-    cmake_conf.set('PROJECT_NAME', meson.project_name())
-    cmake_conf.set('PROJECT_VERSION', meson.project_version())
-    cmake_conf.set('PROJECT_VERSION_MAJOR', meson.project_version().split('.')[0])
-    cmake_conf.set('NLOHMANN_JSON_TARGET_NAME', meson.project_name())
-    cmake_conf.set('NLOHMANN_JSON_TARGETS_EXPORT_NAME', meson.project_name() + 'Targets')
-    cmake_conf.set('NLOHMANN_JSON_INCLUDE_DIR', cmake_include_dir)
-    cmake_conf.set('NLOHMANN_JSON_CONFIG_TO_PREFIX', '/'.join(cmake_to_prefix))
-    cmake_conf.set('NLOHMANN_JSON_COMPILE_DEFINITIONS', ';'.join(json_defines))
-
-    foreach cmake_file : [
-        ['cmake/config.cmake.in', 'nlohmann_jsonConfig.cmake'],
-        ['cmake/nlohmann_jsonConfigVersion.cmake.in', 'nlohmann_jsonConfigVersion.cmake'],
-        ['cmake/nlohmann_jsonTargets.cmake.in', 'nlohmann_jsonTargets.cmake'],
-    ]
-        configure_file(
-            input: cmake_file[0],
-            output: cmake_file[1],
-            configuration: cmake_conf,
-            format: 'cmake@',
-            install_dir: cmake_install_dir,
-        )
-    endforeach
 endif

meson_options.txt

@@ -1,48 +0,0 @@
-option(
-    'MultipleHeaders',
-    type: 'boolean',
-    value: false,
-    description: 'Use non-amalgamated version of the library',
-)
-option(
-    'GlobalUDLs',
-    type: 'boolean',
-    value: true,
-    description: 'Place user-defined string literals in the global namespace',
-)
-option(
-    'ImplicitConversions',
-    type: 'boolean',
-    value: true,
-    description: 'Enable implicit conversions',
-)
-option(
-    'DisableEnumSerialization',
-    type: 'boolean',
-    value: false,
-    description: 'Disable default integer enum serialization',
-)
-option(
-    'Diagnostics',
-    type: 'boolean',
-    value: false,
-    description: 'Use extended diagnostic messages',
-)
-option(
-    'Diagnostic_Positions',
-    type: 'boolean',
-    value: false,
-    description: 'Enable diagnostic positions',
-)
-option(
-    'LegacyDiscardedValueComparison',
-    type: 'boolean',
-    value: false,
-    description: 'Enable legacy discarded value comparison',
-)
-option(
-    'StrictNulHandling',
-    type: 'boolean',
-    value: false,
-    description: 'Enable strict NUL-byte handling',
-)

single_include/nlohmann/json.hpp

@@ -19179,6 +19179,10 @@ class json_pointer
     @return const reference to the JSON value pointed to by the JSON
     pointer
 
+    @pre Every object key and array index the pointer refers to exists.
+         Like the const operator[] for keys and indices, a missing one is
+         undefined behavior, guarded by a runtime assertion.
+
     @throw parse_error.106   if an array index begins with '0'
     @throw parse_error.109   if an array index was not a number
     @throw out_of_range.402  if the array index '-' is used
@@ -19193,7 +19197,8 @@ class json_pointer
             {
                 case detail::value_t::object:
                 {
-                    // use unchecked object access
+                    // use unchecked object access; the const operator[]
+                    // asserts that the key exists
                     ptr = &ptr->operator[](reference_token);
                     break;
                 }
@@ -19206,7 +19211,8 @@ class json_pointer
                         JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
                     }
 
-                    // use unchecked array access
+                    // use unchecked array access; the const operator[]
+                    // asserts that the index exists
                     ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                     break;
                 }
@@ -28749,6 +28755,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         // const operator[] only works for arrays
         if (JSON_HEDLEY_LIKELY(is_array()))
         {
+            JSON_ASSERT(idx < m_data.m_value.array->size());
             return m_data.m_value.array->operator[](idx);
         }