Don't rely on array size to get the length of string literals

bblanchon · bblanchon · commit 1a08caa02e25 · 2025-10-24T14:17:53.000+02:00
See #2189
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,8 @@ HEAD
 
 > ### BREAKING CHANGES
 >
+> #### `JsonString` constructor's boolean parameter
+>
 > Since version 7.3, you could pass a boolean to `JsonString`'s constructor to force the string to be stored by pointer.
 > This optimization has been removed, and you'll get a deprecation warning if you use it.
 > To fix the issue, you must remove the boolean argument from the constructor, or better yet, remove `JsonString` altogether.
@@ -20,6 +22,18 @@ HEAD
 > - doc["name"] = JsonString(name, true);
 > + doc["name"] = name;
 > ```
+>
+> #### NUL characters in string literals
+> 
+> Since version 7.3, ArduinoJson supported NUL characters (`\0`) in string literals.
+> This feature has been removed as part of the storage policy change.
+>
+> If you do need to include NULs in your string, you must use a `JsonString` instead:
+>
+> ```diff
+> - doc["strings"] = "hello\0world"
+> + doc["strings"] = JsonString("hello\0world", 11)
+> ```
 
 v7.4.2 (2025-06-20)
 ------
diff --git a/extras/tests/JsonDocument/remove.cpp b/extras/tests/JsonDocument/remove.cpp
@@ -22,10 +22,10 @@ TEST_CASE("JsonDocument::remove()") {
 
   SECTION("string literal") {
     doc["a"] = 1;
-    doc["a\0b"_s] = 2;
+    doc["ab"_s] = 2;
     doc["b"] = 3;
 
-    doc.remove("a\0b");
+    doc.remove("ab");
 
     REQUIRE(doc.as<std::string>() == "{\"a\":1,\"b\":3}");
   }
diff --git a/extras/tests/JsonDocument/subscript.cpp b/extras/tests/JsonDocument/subscript.cpp
@@ -14,7 +14,7 @@ TEST_CASE("JsonDocument::operator[]") {
 
   SECTION("object") {
     doc["abc"_s] = "ABC";
-    doc["abc\0d"_s] = "ABCD";
+    doc["abcd"_s] = "ABCD";
 
     SECTION("const char*") {
       const char* key = "abc";
@@ -25,20 +25,20 @@ TEST_CASE("JsonDocument::operator[]") {
     SECTION("string literal") {
       REQUIRE(doc["abc"] == "ABC");
       REQUIRE(cdoc["abc"] == "ABC");
-      REQUIRE(doc["abc\0d"] == "ABCD");
-      REQUIRE(cdoc["abc\0d"] == "ABCD");
+      REQUIRE(doc["abcd"] == "ABCD");
+      REQUIRE(cdoc["abcd"] == "ABCD");
     }
 
     SECTION("std::string") {
       REQUIRE(doc["abc"_s] == "ABC");
       REQUIRE(cdoc["abc"_s] == "ABC");
-      REQUIRE(doc["abc\0d"_s] == "ABCD");
-      REQUIRE(cdoc["abc\0d"_s] == "ABCD");
+      REQUIRE(doc["abcd"_s] == "ABCD");
+      REQUIRE(cdoc["abcd"_s] == "ABCD");
     }
 
     SECTION("JsonVariant") {
       doc["key1"] = "abc";
-      doc["key2"] = "abc\0d"_s;
+      doc["key2"] = "abcd"_s;
       doc["key3"] = "foo";
 
       CHECK(doc[doc["key1"]] == "ABC");
diff --git a/extras/tests/JsonVariant/set.cpp b/extras/tests/JsonVariant/set.cpp
@@ -18,10 +18,10 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("string literal") {
-    bool result = variant.set("hello\0world");
+    bool result = variant.set("hello world");
 
     REQUIRE(result == true);
-    REQUIRE(variant == "hello\0world"_s);  // stores by copy
+    REQUIRE(variant == "hello world"_s);  // stores by copy
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofString(11)),
                          });
diff --git a/extras/tests/JsonVariantConst/subscript.cpp b/extras/tests/JsonVariantConst/subscript.cpp
@@ -52,12 +52,12 @@ TEST_CASE("JsonVariantConst::operator[]") {
     JsonObject object = doc.to<JsonObject>();
     object["ab"_s] = "AB";
     object["abc"_s] = "ABC";
-    object["abc\0d"_s] = "ABCD";
+    object["abcd"_s] = "ABCD";
 
     SECTION("string literal") {
       REQUIRE(var["ab"] == "AB"_s);
       REQUIRE(var["abc"] == "ABC"_s);
-      REQUIRE(var["abc\0d"] == "ABCD"_s);
+      REQUIRE(var["abcd"] == "ABCD"_s);
       REQUIRE(var["def"].isNull());
       REQUIRE(var[0].isNull());
     }
@@ -73,7 +73,7 @@ TEST_CASE("JsonVariantConst::operator[]") {
     SECTION("supports std::string") {
       REQUIRE(var["ab"_s] == "AB"_s);
       REQUIRE(var["abc"_s] == "ABC"_s);
-      REQUIRE(var["abc\0d"_s] == "ABCD"_s);
+      REQUIRE(var["abcd"_s] == "ABCD"_s);
       REQUIRE(var["def"_s].isNull());
     }
 
@@ -91,7 +91,7 @@ TEST_CASE("JsonVariantConst::operator[]") {
     SECTION("supports JsonVariant") {
       object["key1"] = "ab";
       object["key2"] = "abc";
-      object["key3"] = "abc\0d"_s;
+      object["key3"] = "abcd"_s;
       object["key4"] = "foo";
 
       REQUIRE(var[var["key1"]] == "AB"_s);
diff --git a/extras/tests/Misc/StringAdapters.cpp b/extras/tests/Misc/StringAdapters.cpp
@@ -21,7 +21,7 @@ TEST_CASE("adaptString()") {
     auto s = adaptString("bravo\0alpha");
 
     CHECK(s.isNull() == false);
-    CHECK(s.size() == 11);
+    CHECK(s.size() == 5);
   }
 
   SECTION("null const char*") {
diff --git a/src/ArduinoJson/Document/JsonDocument.hpp b/src/ArduinoJson/Document/JsonDocument.hpp
@@ -145,8 +145,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
 
   // Replaces the root with the specified value.
   // https://arduinojson.org/v7/api/jsondocument/set/
-  template <typename TChar,
-            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  template <typename TChar>
   bool set(TChar* src) {
     return to<JsonVariant>().set(src);
   }
@@ -218,9 +217,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Gets or sets a root object's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   detail::MemberProxy<JsonDocument&, detail::AdaptedString<TChar*>> operator[](
       TChar* key) {
     return {*this, detail::adaptString(key)};
@@ -238,9 +235,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Gets a root object's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(
         getVariantImpl().getMember(detail::adaptString(key)), &resources_);
@@ -299,8 +294,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
-  template <typename TChar,
-            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  template <typename TChar>
   bool add(TChar* value) {
     return getOrCreateArray().add(value);
   }
@@ -316,9 +310,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Removes a member of the root object.
   // https://arduinojson.org/v7/api/jsondocument/remove/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   void remove(TChar* key) {
     getVariantImpl().removeMember(detail::adaptString(key));
   }
diff --git a/src/ArduinoJson/Object/JsonObject.hpp b/src/ArduinoJson/Object/JsonObject.hpp
@@ -110,9 +110,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // Gets or sets the member with specified key.
   // https://arduinojson.org/v7/api/jsonobject/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   detail::MemberProxy<JsonObject, detail::AdaptedString<TChar*>> operator[](
       TChar* key) const {
     return {*this, detail::adaptString(key)};
@@ -169,9 +167,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // DEPRECATED: use obj["key"].is<T>() instead
   // https://arduinojson.org/v7/api/jsonobject/containskey/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
     return impl_.getMember(detail::adaptString(key)) != 0;
diff --git a/src/ArduinoJson/Object/JsonObjectConst.hpp b/src/ArduinoJson/Object/JsonObjectConst.hpp
@@ -106,9 +106,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
   // Gets the member with specified key.
   // https://arduinojson.org/v7/api/jsonobjectconst/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
                             impl_.resources());
diff --git a/src/ArduinoJson/Object/MemberProxy.hpp b/src/ArduinoJson/Object/MemberProxy.hpp
@@ -39,7 +39,7 @@ class MemberProxy
     return *this;
   }
 
-  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  template <typename T>
   MemberProxy& operator=(T* src) {
     this->set(src);
     return *this;
diff --git a/src/ArduinoJson/Strings/Adapters/RamString.hpp b/src/ArduinoJson/Strings/Adapters/RamString.hpp
@@ -58,36 +58,6 @@ struct StringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
   }
 };
 
-template <typename TChar>
-struct StringAdapter<TChar[], enable_if_t<IsChar<TChar>::value>> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const TChar* p) {
-    auto str = reinterpret_cast<const char*>(p);
-    return AdaptedString(str, str ? ::strlen(str) : 0);
-  }
-};
-
-template <size_t N>
-struct StringAdapter<const char (&)[N]> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const char (&p)[N]) {
-    return RamString(p, N - 1);
-  }
-};
-
-template <typename TChar, size_t N>
-struct StringAdapter<TChar[N], enable_if_t<IsChar<TChar>::value>> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const TChar* p) {
-    ARDUINOJSON_ASSERT(p);
-    auto str = reinterpret_cast<const char*>(p);
-    return AdaptedString(str, ::strlen(str));
-  }
-};
-
 template <typename TChar>
 struct SizedStringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
   using AdaptedString = RamString;
diff --git a/src/ArduinoJson/Strings/StringAdapter.hpp b/src/ArduinoJson/Strings/StringAdapter.hpp
@@ -8,13 +8,6 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-// a meta function that tells if the type is a string literal (const char[N])
-template <typename T>
-struct IsStringLiteral : false_type {};
-
-template <size_t N>
-struct IsStringLiteral<const char (&)[N]> : true_type {};
-
 template <typename TString, typename Enable = void>
 struct StringAdapter;
 
@@ -23,8 +16,7 @@ struct SizedStringAdapter;
 
 template <typename TString>
 using StringAdapterFor =
-    StringAdapter<conditional_t<IsStringLiteral<TString>::value, TString,
-                                remove_cv_t<remove_reference_t<TString>>>>;
+    StringAdapter<remove_cv_t<remove_reference_t<TString>>>;
 
 template <typename T>
 using AdaptedString = typename StringAdapterFor<T>::AdaptedString;
@@ -34,7 +26,7 @@ AdaptedString<TString> adaptString(TString&& s) {
   return StringAdapterFor<TString>::adapt(detail::forward<TString>(s));
 }
 
-template <typename TChar, enable_if_t<!is_const<TChar>::value, int> = 0>
+template <typename TChar>
 AdaptedString<TChar*> adaptString(TChar* p) {
   return StringAdapter<TChar*>::adapt(p);
 }
diff --git a/src/ArduinoJson/Variant/JsonVariantConst.hpp b/src/ArduinoJson/Variant/JsonVariantConst.hpp
@@ -119,9 +119,7 @@ class JsonVariantConst : public detail::VariantTag,
   // Gets object's member with specified key.
   // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
                             impl_.resources());
@@ -151,9 +149,7 @@ class JsonVariantConst : public detail::VariantTag,
   // DEPRECATED: use obj["key"].is<T>() instead
   // https://arduinojson.org/v7/api/jsonvariantconst/containskey/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
     return impl_.getMember(detail::adaptString(key)) != 0;
diff --git a/src/ArduinoJson/Variant/VariantRefBase.hpp b/src/ArduinoJson/Variant/VariantRefBase.hpp
@@ -76,15 +76,13 @@ class VariantRefBase : public VariantTag {
   // https://arduinojson.org/v7/api/jsonvariant/set/
   template <typename T>
   bool set(const T& value) const {
-    using TypeForConverter = conditional_t<IsStringLiteral<T>::value, T,
-                                           remove_cv_t<remove_reference_t<T>>>;
+    using TypeForConverter = remove_cv_t<remove_reference_t<T>>;
     return doSet<Converter<TypeForConverter>>(value);
   }
 
   // Copies the specified value.
   // https://arduinojson.org/v7/api/jsonvariant/set/
-  template <typename T,
-            detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
+  template <typename T>
   bool set(T* value) const {
     return doSet<Converter<T*>>(value);
   }
@@ -124,7 +122,7 @@ class VariantRefBase : public VariantTag {
 
   // Appends a value to the array.
   // https://arduinojson.org/v7/api/jsonvariant/add/
-  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  template <typename T>
   bool add(T* value) const {
     return getOrCreateArray().add(value);
   }
@@ -189,9 +187,7 @@ class VariantRefBase : public VariantTag {
 
   // Gets or sets an object member.
   // https://arduinojson.org/v7/api/jsonvariant/subscript/
-  template <
-      typename TChar,
-      enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int> = 0>
+  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
   FORCE_INLINE MemberProxy<TDerived, AdaptedString<TChar*>> operator[](
       TChar* key) const;
 
diff --git a/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp b/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp
@@ -124,8 +124,7 @@ inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](
 }
 
 template <typename TDerived>
-template <typename TChar,
-          enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int>>
+template <typename TChar, enable_if_t<IsString<TChar*>::value, int>>
 inline MemberProxy<TDerived, AdaptedString<TChar*>>
 VariantRefBase<TDerived>::operator[](TChar* key) const {
   return {derived(), adaptString(key)};

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ TEST_CASE("adaptString()") {`
`21`	`21`	`auto s = adaptString("bravo\0alpha");`
`22`	`22`
`23`	`23`	`CHECK(s.isNull() == false);`
`24`		`- CHECK(s.size() == 11);`
	`24`	`+ CHECK(s.size() == 5);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`SECTION("null const char*") {`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class MemberProxy`
`39`	`39`	`return *this;`
`40`	`40`	`}`
`41`	`41`
`42`		`- template <typename T, enable_if_t<!is_const<T>::value, int> = 0>`
	`42`	`+ template <typename T>`
`43`	`43`	`MemberProxy& operator=(T* src) {`
`44`	`44`	`this->set(src);`
`45`	`45`	`return *this;`