Reject integer lengths in json_document::parse

parse(ptr, len) compiled: len converted to allow_exceptions, and ptr was
read as a C string, past the end of a buffer without a terminating NUL.
Delete the overloads of parse, parse_copy, accept, and read that take an
integer other than bool where the flags are expected.

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

tests/src/unit-json_view.cpp

@@ -15,12 +15,14 @@ using nlohmann::json_document;
 using nlohmann::json_view;
 using nlohmann::ordered_json_document;
 
+#include <cstddef>
 #include <cstdint>
 #include <list>
 #include <map>
 #include <random>
 #include <sstream>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -30,6 +32,16 @@ using nlohmann::ordered_json_document;
 
 namespace
 {
+// detection of calls that must not compile
+template<typename... Args>
+using parse_call_t = decltype(json_document::parse(std::declval<Args>()...));
+template<typename... Args>
+using parse_copy_call_t = decltype(json_document::parse_copy(std::declval<Args>()...));
+template<typename... Args>
+using accept_call_t = decltype(json_document::accept(std::declval<Args>()...));
+template<typename... Args>
+using read_call_t = decltype(std::declval<json_document&>().read(std::declval<Args>()...));
+
 #if !defined(JSON_NOEXCEPTION)
 // the exception parse() throws for a text, or "" if it accepts it
 std::string parse_exception(const std::string& text, bool comments = false, bool trailing_commas = false)
@@ -329,6 +341,38 @@ TEST_CASE("json_view")
         CHECK(json_document::parse("", false).is_discarded());
     }
 
+    SECTION("integer arguments do not compile")
+    {
+        using nlohmann::detail::is_detected;
+
+        // a length is not a flag: parse(ptr, len) would convert len to
+        // allow_exceptions and read ptr as a C string, which need not end
+        static_assert(is_detected<parse_call_t, const char*, bool>::value, "parse(ptr, bool) is valid");
+        static_assert(is_detected<parse_call_t, const char*, bool, bool, bool>::value, "parse(ptr, bool, bool, bool) is valid");
+        static_assert(is_detected<parse_call_t, const char*, const char*>::value, "parse(first, last) is valid");
+        static_assert(is_detected<parse_call_t, const char*, const char*, bool>::value, "parse(first, last, bool) is valid");
+        static_assert(!is_detected<parse_call_t, const char*, std::size_t>::value, "parse(ptr, len) must not compile");
+        static_assert(!is_detected<parse_call_t, const char*, int>::value, "parse(ptr, int) must not compile");
+        static_assert(!is_detected<parse_call_t, const char*, char>::value, "parse(ptr, char) must not compile");
+        static_assert(!is_detected<parse_call_t, const char*, std::size_t, bool>::value, "parse(ptr, len, bool) must not compile");
+        static_assert(!is_detected<parse_call_t, const std::string&, std::size_t>::value, "parse(string, len) must not compile");
+        static_assert(!is_detected<parse_call_t, const std::vector<char>&, std::size_t>::value, "parse(vector, len) must not compile");
+
+        static_assert(is_detected<parse_copy_call_t, const char*, bool>::value, "parse_copy(ptr, bool) is valid");
+        static_assert(!is_detected<parse_copy_call_t, const char*, std::size_t>::value, "parse_copy(ptr, len) must not compile");
+
+        static_assert(is_detected<accept_call_t, const char*, bool>::value, "accept(ptr, bool) is valid");
+        static_assert(!is_detected<accept_call_t, const char*, std::size_t>::value, "accept(ptr, len) must not compile");
+
+        static_assert(is_detected<read_call_t, const char*, bool>::value, "read(ptr, bool) is valid");
+        static_assert(!is_detected<read_call_t, const char*, std::size_t>::value, "read(ptr, len) must not compile");
+
+        // the valid calls still work
+        const char* const text = "[1]";
+        CHECK(json_document::parse(text, true).root().is_array());
+        CHECK(json_document::accept(text, true, true));
+    }
+
     SECTION("document lifetime and reuse")
     {
         json_document d;