From b0730f04f7525d94e063b64fdcff95cd756ec4e8 Mon Sep 17 00:00:00 2001
From: Benoit Blanchon <git@benoitblanchon.fr>
Date: Mon, 19 Dec 2022 12:07:40 +0100
Subject: [PATCH] Rename `VariantRef` to `JsonVariant`

---
 extras/tests/JsonVariant/converters.cpp       |  2 +-
 extras/tests/Misc/TypeTraits.cpp              |  2 +-
 src/ArduinoJson.hpp                           | 16 ++++++------
 src/ArduinoJson/Array/JsonArray.hpp           | 16 ++++++------
 src/ArduinoJson/Array/JsonArrayConst.hpp      |  2 +-
 src/ArduinoJson/Array/JsonArrayIterator.hpp   | 12 ++++-----
 src/ArduinoJson/Array/Utilities.hpp           |  2 +-
 .../Document/BasicJsonDocument.hpp            |  4 +--
 src/ArduinoJson/Document/JsonDocument.hpp     | 16 ++++++------
 .../Document/StaticJsonDocument.hpp           |  2 +-
 src/ArduinoJson/Object/JsonObject.hpp         | 10 +++----
 src/ArduinoJson/Object/JsonObjectConst.hpp    |  2 +-
 src/ArduinoJson/Object/JsonPair.hpp           |  8 +++---
 src/ArduinoJson/Variant/ConverterImpl.hpp     | 26 +++++++++----------
 .../{VariantRef.hpp => JsonVariant.hpp}       | 20 +++++++-------
 src/ArduinoJson/Variant/VariantImpl.hpp       | 20 +++++++-------
 src/ArduinoJson/Variant/VariantOperators.hpp  |  2 +-
 src/ArduinoJson/Variant/VariantRefBase.hpp    | 12 ++++-----
 src/ArduinoJson/Variant/VariantTo.hpp         |  8 +++---
 19 files changed, 92 insertions(+), 90 deletions(-)
 rename src/ArduinoJson/Variant/{VariantRef.hpp => JsonVariant.hpp} (67%)

diff --git a/extras/tests/JsonVariant/converters.cpp b/extras/tests/JsonVariant/converters.cpp
index 93e73912..7281f2ba 100644
--- a/extras/tests/JsonVariant/converters.cpp
+++ b/extras/tests/JsonVariant/converters.cpp
@@ -91,7 +91,7 @@ class Complex {
 namespace ARDUINOJSON_NAMESPACE {
 template <>
 struct Converter<Complex> {
-  static void toJson(const Complex& src, VariantRef dst) {
+  static void toJson(const Complex& src, JsonVariant dst) {
     dst["real"] = src.real();
     dst["imag"] = src.imag();
   }
diff --git a/extras/tests/Misc/TypeTraits.cpp b/extras/tests/Misc/TypeTraits.cpp
index 976286aa..76ec4861 100644
--- a/extras/tests/Misc/TypeTraits.cpp
+++ b/extras/tests/Misc/TypeTraits.cpp
@@ -181,7 +181,7 @@ TEST_CASE("Polyfills/type_traits") {
     CHECK((is_convertible<DeserializationError, JsonVariantConst>::value ==
            false));
     CHECK((is_convertible<JsonPair, JsonVariantConst>::value == false));
-    CHECK((is_convertible<VariantRef, JsonVariantConst>::value == true));
+    CHECK((is_convertible<JsonVariant, JsonVariantConst>::value == true));
     CHECK((is_convertible<JsonVariantConst, JsonVariantConst>::value == true));
     CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true));
     CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value ==
diff --git a/src/ArduinoJson.hpp b/src/ArduinoJson.hpp
index c6868581..3a490f33 100644
--- a/src/ArduinoJson.hpp
+++ b/src/ArduinoJson.hpp
@@ -47,8 +47,15 @@
 #include "ArduinoJson/compatibility.hpp"
 
 namespace ArduinoJson {
+using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
+using ARDUINOJSON_NAMESPACE::copyArray;
+using ARDUINOJSON_NAMESPACE::DeserializationError;
+using ARDUINOJSON_NAMESPACE::deserializeJson;
+using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
+using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
 using ARDUINOJSON_NAMESPACE::JsonArray;
 using ARDUINOJSON_NAMESPACE::JsonArrayConst;
+using ARDUINOJSON_NAMESPACE::JsonDocument;
 using ARDUINOJSON_NAMESPACE::JsonFloat;
 using ARDUINOJSON_NAMESPACE::JsonInteger;
 using ARDUINOJSON_NAMESPACE::JsonObject;
@@ -57,15 +64,8 @@ using ARDUINOJSON_NAMESPACE::JsonPair;
 using ARDUINOJSON_NAMESPACE::JsonPairConst;
 using ARDUINOJSON_NAMESPACE::JsonString;
 using ARDUINOJSON_NAMESPACE::JsonUInt;
+using ARDUINOJSON_NAMESPACE::JsonVariant;
 using ARDUINOJSON_NAMESPACE::JsonVariantConst;
-typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
-using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
-using ARDUINOJSON_NAMESPACE::copyArray;
-using ARDUINOJSON_NAMESPACE::DeserializationError;
-using ARDUINOJSON_NAMESPACE::deserializeJson;
-using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
-using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
-using ARDUINOJSON_NAMESPACE::JsonDocument;
 using ARDUINOJSON_NAMESPACE::measureJson;
 using ARDUINOJSON_NAMESPACE::serialized;
 using ARDUINOJSON_NAMESPACE::serializeJson;
diff --git a/src/ArduinoJson/Array/JsonArray.hpp b/src/ArduinoJson/Array/JsonArray.hpp
index aab19a26..4094a6f0 100644
--- a/src/ArduinoJson/Array/JsonArray.hpp
+++ b/src/ArduinoJson/Array/JsonArray.hpp
@@ -21,19 +21,19 @@ class JsonArray : public VariantOperators<JsonArray> {
   FORCE_INLINE JsonArray(MemoryPool* pool, CollectionData* data)
       : _data(data), _pool(pool) {}
 
-  operator VariantRef() {
+  operator JsonVariant() {
     void* data = _data;  // prevent warning cast-align
-    return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
   }
 
   operator JsonArrayConst() const {
     return JsonArrayConst(_data);
   }
 
-  VariantRef add() const {
+  JsonVariant add() const {
     if (!_data)
-      return VariantRef();
-    return VariantRef(_pool, _data->addElement(_pool));
+      return JsonVariant();
+    return JsonVariant(_pool, _data->addElement(_pool));
   }
 
   template <typename T>
@@ -141,11 +141,11 @@ class JsonArray : public VariantOperators<JsonArray> {
 
 template <>
 struct Converter<JsonArray> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonArray fromJson(VariantRef src) {
+  static JsonArray fromJson(JsonVariant src) {
     VariantData* data = getData(src);
     MemoryPool* pool = getPool(src);
     return JsonArray(pool, data != 0 ? data->asArray() : 0);
@@ -158,7 +158,7 @@ struct Converter<JsonArray> : private VariantAttorney {
     return false;
   }
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return data && data->isArray();
   }
diff --git a/src/ArduinoJson/Array/JsonArrayConst.hpp b/src/ArduinoJson/Array/JsonArrayConst.hpp
index 8490542d..815a07e1 100644
--- a/src/ArduinoJson/Array/JsonArrayConst.hpp
+++ b/src/ArduinoJson/Array/JsonArrayConst.hpp
@@ -93,7 +93,7 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
 
 template <>
 struct Converter<JsonArrayConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
diff --git a/src/ArduinoJson/Array/JsonArrayIterator.hpp b/src/ArduinoJson/Array/JsonArrayIterator.hpp
index deb3b1a3..382d1177 100644
--- a/src/ArduinoJson/Array/JsonArrayIterator.hpp
+++ b/src/ArduinoJson/Array/JsonArrayIterator.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 #include <ArduinoJson/Variant/SlotFunctions.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 
@@ -13,16 +13,16 @@ class VariantPtr {
  public:
   VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {}
 
-  VariantRef* operator->() {
+  JsonVariant* operator->() {
     return &_variant;
   }
 
-  VariantRef& operator*() {
+  JsonVariant& operator*() {
     return _variant;
   }
 
  private:
-  VariantRef _variant;
+  JsonVariant _variant;
 };
 
 class JsonArrayIterator {
@@ -33,8 +33,8 @@ class JsonArrayIterator {
   explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot)
       : _pool(pool), _slot(slot) {}
 
-  VariantRef operator*() const {
-    return VariantRef(_pool, _slot->data());
+  JsonVariant operator*() const {
+    return JsonVariant(_pool, _slot->data());
   }
   VariantPtr operator->() {
     return VariantPtr(_pool, _slot->data());
diff --git a/src/ArduinoJson/Array/Utilities.hpp b/src/ArduinoJson/Array/Utilities.hpp
index 93237c52..5b611b64 100644
--- a/src/ArduinoJson/Array/Utilities.hpp
+++ b/src/ArduinoJson/Array/Utilities.hpp
@@ -12,7 +12,7 @@ namespace ARDUINOJSON_NAMESPACE {
 // Trivial form to stop the recursion
 template <typename T>
 inline typename enable_if<!is_array<T>::value, bool>::type copyArray(
-    const T& src, VariantRef dst) {
+    const T& src, JsonVariant dst) {
   return dst.set(src);
 }
 
diff --git a/src/ArduinoJson/Document/BasicJsonDocument.hpp b/src/ArduinoJson/Document/BasicJsonDocument.hpp
index bc3e9b04..6e522f43 100644
--- a/src/ArduinoJson/Document/BasicJsonDocument.hpp
+++ b/src/ArduinoJson/Document/BasicJsonDocument.hpp
@@ -65,7 +65,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
   BasicJsonDocument(
       const T& src,
       typename enable_if<
-          is_same<T, VariantRef>::value ||
+          is_same<T, JsonVariant>::value ||
           is_same<T, JsonVariantConst>::value || is_same<T, JsonArray>::value ||
           is_same<T, JsonArrayConst>::value || is_same<T, JsonObject>::value ||
           is_same<T, JsonObjectConst>::value>::type* = 0)
@@ -74,7 +74,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
   }
 
   // disambiguate
-  BasicJsonDocument(VariantRef src)
+  BasicJsonDocument(JsonVariant src)
       : JsonDocument(allocPool(src.memoryUsage())) {
     set(src);
   }
diff --git a/src/ArduinoJson/Document/JsonDocument.hpp b/src/ArduinoJson/Document/JsonDocument.hpp
index 236667e4..82031ab8 100644
--- a/src/ArduinoJson/Document/JsonDocument.hpp
+++ b/src/ArduinoJson/Document/JsonDocument.hpp
@@ -68,13 +68,13 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   }
 
   bool set(const JsonDocument& src) {
-    return to<VariantRef>().set(src.as<JsonVariantConst>());
+    return to<JsonVariant>().set(src.as<JsonVariantConst>());
   }
 
   template <typename T>
   typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
       const T& src) {
-    return to<VariantRef>().set(src);
+    return to<JsonVariant>().set(src);
   }
 
   template <typename T>
@@ -182,8 +182,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     return JsonVariantConst(_data.getElement(index));
   }
 
-  FORCE_INLINE VariantRef add() {
-    return VariantRef(&_pool, _data.addElement(&_pool));
+  FORCE_INLINE JsonVariant add() {
+    return JsonVariant(&_pool, _data.addElement(&_pool));
   }
 
   template <typename TValue>
@@ -218,7 +218,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     _data.remove(adaptString(key));
   }
 
-  FORCE_INLINE operator VariantRef() {
+  FORCE_INLINE operator JsonVariant() {
     return getVariant();
   }
 
@@ -245,8 +245,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     _pool = pool;
   }
 
-  VariantRef getVariant() {
-    return VariantRef(&_pool, &_data);
+  JsonVariant getVariant() {
+    return JsonVariant(&_pool, &_data);
   }
 
   JsonVariantConst getVariant() const {
@@ -278,7 +278,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   }
 };
 
-inline void convertToJson(const JsonDocument& src, VariantRef dst) {
+inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
   dst.set(src.as<JsonVariantConst>());
 }
 
diff --git a/src/ArduinoJson/Document/StaticJsonDocument.hpp b/src/ArduinoJson/Document/StaticJsonDocument.hpp
index 1c369e14..b5cad3f0 100644
--- a/src/ArduinoJson/Document/StaticJsonDocument.hpp
+++ b/src/ArduinoJson/Document/StaticJsonDocument.hpp
@@ -30,7 +30,7 @@ class StaticJsonDocument : public JsonDocument {
   }
 
   // disambiguate
-  StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) {
+  StaticJsonDocument(JsonVariant src) : JsonDocument(_buffer, _capacity) {
     set(src);
   }
 
diff --git a/src/ArduinoJson/Object/JsonObject.hpp b/src/ArduinoJson/Object/JsonObject.hpp
index 9ff74bf3..ed14a3f6 100644
--- a/src/ArduinoJson/Object/JsonObject.hpp
+++ b/src/ArduinoJson/Object/JsonObject.hpp
@@ -21,9 +21,9 @@ class JsonObject : public VariantOperators<JsonObject> {
   FORCE_INLINE JsonObject(MemoryPool* buf, CollectionData* data)
       : _data(data), _pool(buf) {}
 
-  operator VariantRef() const {
+  operator JsonVariant() const {
     void* data = _data;  // prevent warning cast-align
-    return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
   }
 
   operator JsonObjectConst() const {
@@ -176,11 +176,11 @@ class JsonObject : public VariantOperators<JsonObject> {
 
 template <>
 struct Converter<JsonObject> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonObject fromJson(VariantRef src) {
+  static JsonObject fromJson(JsonVariant src) {
     VariantData* data = getData(src);
     MemoryPool* pool = getPool(src);
     return JsonObject(pool, data != 0 ? data->asObject() : 0);
@@ -193,7 +193,7 @@ struct Converter<JsonObject> : private VariantAttorney {
     return false;
   }
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return data && data->isObject();
   }
diff --git a/src/ArduinoJson/Object/JsonObjectConst.hpp b/src/ArduinoJson/Object/JsonObjectConst.hpp
index d83ff785..95d8279d 100644
--- a/src/ArduinoJson/Object/JsonObjectConst.hpp
+++ b/src/ArduinoJson/Object/JsonObjectConst.hpp
@@ -120,7 +120,7 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
 
 template <>
 struct Converter<JsonObjectConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
diff --git a/src/ArduinoJson/Object/JsonPair.hpp b/src/ArduinoJson/Object/JsonPair.hpp
index 50cfba5f..994ed6c2 100644
--- a/src/ArduinoJson/Object/JsonPair.hpp
+++ b/src/ArduinoJson/Object/JsonPair.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 #include <ArduinoJson/Variant/JsonVariantConst.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 // A key value pair for CollectionData.
@@ -16,7 +16,7 @@ class JsonPair {
     if (slot) {
       _key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
                                                      : JsonString::Linked);
-      _value = VariantRef(pool, slot->data());
+      _value = JsonVariant(pool, slot->data());
     }
   }
 
@@ -24,13 +24,13 @@ class JsonPair {
     return _key;
   }
 
-  VariantRef value() const {
+  JsonVariant value() const {
     return _value;
   }
 
  private:
   JsonString _key;
-  VariantRef _value;
+  JsonVariant _value;
 };
 
 class JsonPairConst {
diff --git a/src/ArduinoJson/Variant/ConverterImpl.hpp b/src/ArduinoJson/Variant/ConverterImpl.hpp
index f0fff043..f74bcfee 100644
--- a/src/ArduinoJson/Variant/ConverterImpl.hpp
+++ b/src/ArduinoJson/Variant/ConverterImpl.hpp
@@ -12,7 +12,7 @@ namespace ARDUINOJSON_NAMESPACE {
 
 template <typename T, typename Enable>
 struct Converter {
-  static void toJson(const T& src, VariantRef dst) {
+  static void toJson(const T& src, JsonVariant dst) {
     // clang-format off
     convertToJson(src, dst); // Error here? See https://arduinojson.org/v6/unsupported-set/
     // clang-format on
@@ -39,7 +39,7 @@ struct Converter<
     T, typename enable_if<is_integral<T>::value && !is_same<bool, T>::value &&
                           !is_same<char, T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     VariantData* data = getData(dst);
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
     if (data)
@@ -61,7 +61,7 @@ struct Converter<
 template <typename T>
 struct Converter<T, typename enable_if<is_enum<T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     dst.set(static_cast<JsonInteger>(src));
   }
 
@@ -78,7 +78,7 @@ struct Converter<T, typename enable_if<is_enum<T>::value>::type>
 
 template <>
 struct Converter<bool> : private VariantAttorney {
-  static void toJson(bool src, VariantRef dst) {
+  static void toJson(bool src, JsonVariant dst) {
     VariantData* data = getData(dst);
     if (data)
       data->setBoolean(src);
@@ -98,7 +98,7 @@ struct Converter<bool> : private VariantAttorney {
 template <typename T>
 struct Converter<T, typename enable_if<is_floating_point<T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     VariantData* data = getData(dst);
     if (data)
       data->setFloat(static_cast<JsonFloat>(src));
@@ -117,7 +117,7 @@ struct Converter<T, typename enable_if<is_floating_point<T>::value>::type>
 
 template <>
 struct Converter<const char*> : private VariantAttorney {
-  static void toJson(const char* src, VariantRef dst) {
+  static void toJson(const char* src, JsonVariant dst) {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
@@ -134,7 +134,7 @@ struct Converter<const char*> : private VariantAttorney {
 
 template <>
 struct Converter<JsonString> : private VariantAttorney {
-  static void toJson(JsonString src, VariantRef dst) {
+  static void toJson(JsonString src, JsonVariant dst) {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
@@ -151,7 +151,7 @@ struct Converter<JsonString> : private VariantAttorney {
 
 template <typename T>
 inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
-    const T& src, VariantRef dst) {
+    const T& src, JsonVariant dst) {
   VariantData* data = VariantAttorney::getData(dst);
   MemoryPool* pool = VariantAttorney::getPool(dst);
   return variantSetString(data, adaptString(src), pool);
@@ -159,7 +159,7 @@ inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
 
 template <>
 struct Converter<SerializedValue<const char*> > {
-  static void toJson(SerializedValue<const char*> src, VariantRef dst) {
+  static void toJson(SerializedValue<const char*> src, JsonVariant dst) {
     VariantData* data = VariantAttorney::getData(dst);
     if (data)
       data->setLinkedRaw(src);
@@ -173,7 +173,7 @@ template <typename T>
 struct Converter<SerializedValue<T>,
                  typename enable_if<!is_same<const char*, T>::value>::type>
     : private VariantAttorney {
-  static void toJson(SerializedValue<T> src, VariantRef dst) {
+  static void toJson(SerializedValue<T> src, JsonVariant dst) {
     VariantData* data = getData(dst);
     MemoryPool* pool = getPool(dst);
     if (data)
@@ -185,7 +185,7 @@ struct Converter<SerializedValue<T>,
 
 template <>
 struct Converter<decltype(nullptr)> : private VariantAttorney {
-  static void toJson(decltype(nullptr), VariantRef dst) {
+  static void toJson(decltype(nullptr), JsonVariant dst) {
     variantSetNull(getData(dst));
   }
   static decltype(nullptr) fromJson(JsonVariantConst) {
@@ -242,7 +242,7 @@ class MemoryPoolPrint : public Print {
   size_t _capacity;
 };
 
-inline void convertToJson(const ::Printable& src, VariantRef dst) {
+inline void convertToJson(const ::Printable& src, JsonVariant dst) {
   MemoryPool* pool = VariantAttorney::getPool(dst);
   VariantData* data = VariantAttorney::getData(dst);
   if (!pool || !data)
@@ -308,7 +308,7 @@ inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
 template <typename T>
 struct ConverterNeedsWriteableRef {
  protected:  // <- to avoid GCC's "all member functions in class are private"
-  static int probe(T (*f)(VariantRef));
+  static int probe(T (*f)(JsonVariant));
   static char probe(T (*f)(JsonVariantConst));
 
  public:
diff --git a/src/ArduinoJson/Variant/VariantRef.hpp b/src/ArduinoJson/Variant/JsonVariant.hpp
similarity index 67%
rename from src/ArduinoJson/Variant/VariantRef.hpp
rename to src/ArduinoJson/Variant/JsonVariant.hpp
index 499d206a..63e01654 100644
--- a/src/ArduinoJson/Variant/VariantRef.hpp
+++ b/src/ArduinoJson/Variant/JsonVariant.hpp
@@ -8,14 +8,14 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class VariantRef : public VariantRefBase<VariantRef>,
-                   public VariantOperators<VariantRef> {
+class JsonVariant : public VariantRefBase<JsonVariant>,
+                    public VariantOperators<JsonVariant> {
   friend class VariantAttorney;
 
  public:
-  VariantRef() : _data(0), _pool(0) {}
+  JsonVariant() : _data(0), _pool(0) {}
 
-  VariantRef(MemoryPool* pool, VariantData* data) : _data(data), _pool(pool) {}
+  JsonVariant(MemoryPool* pool, VariantData* data) : _data(data), _pool(pool) {}
 
  private:
   FORCE_INLINE MemoryPool* getPool() const {
@@ -35,19 +35,19 @@ class VariantRef : public VariantRefBase<VariantRef>,
 };
 
 template <>
-struct Converter<VariantRef> : private VariantAttorney {
-  static void toJson(VariantRef src, VariantRef dst) {
+struct Converter<JsonVariant> : private VariantAttorney {
+  static void toJson(JsonVariant src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static VariantRef fromJson(VariantRef src) {
+  static JsonVariant fromJson(JsonVariant src) {
     return src;
   }
 
-  static InvalidConversion<JsonVariantConst, VariantRef> fromJson(
+  static InvalidConversion<JsonVariantConst, JsonVariant> fromJson(
       JsonVariantConst);
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return !!data;
   }
@@ -59,7 +59,7 @@ struct Converter<VariantRef> : private VariantAttorney {
 
 template <>
 struct Converter<JsonVariantConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
diff --git a/src/ArduinoJson/Variant/VariantImpl.hpp b/src/ArduinoJson/Variant/VariantImpl.hpp
index 02ae1e77..7ea8be1c 100644
--- a/src/ArduinoJson/Variant/VariantImpl.hpp
+++ b/src/ArduinoJson/Variant/VariantImpl.hpp
@@ -9,7 +9,7 @@
 #include <ArduinoJson/Numbers/convertNumber.hpp>
 #include <ArduinoJson/Numbers/parseNumber.hpp>
 #include <ArduinoJson/Object/JsonObject.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 
 #include <string.h>  // for strcmp
 
@@ -105,18 +105,19 @@ inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::add() const {
-  return VariantRef(getPool(), variantAddElement(getOrCreateData(), getPool()));
+inline JsonVariant VariantRefBase<TDerived>::add() const {
+  return JsonVariant(getPool(),
+                     variantAddElement(getOrCreateData(), getPool()));
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::getVariant() const {
-  return VariantRef(getPool(), getData());
+inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
+  return JsonVariant(getPool(), getData());
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::getOrCreateVariant() const {
-  return VariantRef(getPool(), getOrCreateData());
+inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
+  return JsonVariant(getPool(), getOrCreateData());
 }
 
 template <typename TDerived>
@@ -135,7 +136,7 @@ VariantRefBase<TDerived>::to() const {
 
 template <typename TDerived>
 template <typename T>
-typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type
+typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
 VariantRefBase<TDerived>::to() const {
   variantSetNull(getOrCreateData());
   return *this;
@@ -148,7 +149,8 @@ inline bool VariantRefBase<TDerived>::set(char value) const {
 }
 
 template <typename TDerived>
-inline void convertToJson(const VariantRefBase<TDerived>& src, VariantRef dst) {
+inline void convertToJson(const VariantRefBase<TDerived>& src,
+                          JsonVariant dst) {
   dst.set(src.template as<JsonVariantConst>());
 }
 
diff --git a/src/ArduinoJson/Variant/VariantOperators.hpp b/src/ArduinoJson/Variant/VariantOperators.hpp
index a8bbc9ea..b73ff937 100644
--- a/src/ArduinoJson/Variant/VariantOperators.hpp
+++ b/src/ArduinoJson/Variant/VariantOperators.hpp
@@ -21,7 +21,7 @@ struct VariantOperatorTag {};
 
 template <typename TVariant>
 struct VariantOperators : VariantOperatorTag {
-  // Returns the default value if the VariantRef is unbound or incompatible
+  // Returns the default value if the JsonVariant is unbound or incompatible
   //
   // int operator|(JsonVariant, int)
   // float operator|(JsonVariant, float)
diff --git a/src/ArduinoJson/Variant/VariantRefBase.hpp b/src/ArduinoJson/Variant/VariantRefBase.hpp
index 2a37825f..897c41b8 100644
--- a/src/ArduinoJson/Variant/VariantRefBase.hpp
+++ b/src/ArduinoJson/Variant/VariantRefBase.hpp
@@ -12,7 +12,7 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class VariantRef;
+class JsonVariant;
 
 template <typename>
 class ElementProxy;
@@ -83,9 +83,9 @@ class VariantRefBase : public VariantTag {
   typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type to()
       const;
   //
-  // VariantRef to<VariantRef>()
+  // JsonVariant to<JsonVariant>()
   template <typename T>
-  typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to()
+  typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type to()
       const;
 
   template <typename T>
@@ -161,7 +161,7 @@ class VariantRefBase : public VariantTag {
     return variantNesting(getData());
   }
 
-  FORCE_INLINE VariantRef add() const;
+  FORCE_INLINE JsonVariant add() const;
 
   template <typename T>
   FORCE_INLINE bool add(const T& value) const {
@@ -256,13 +256,13 @@ class VariantRefBase : public VariantTag {
   }
 
  private:
-  FORCE_INLINE VariantRef getVariant() const;
+  FORCE_INLINE JsonVariant getVariant() const;
 
   FORCE_INLINE JsonVariantConst getVariantConst() const {
     return JsonVariantConst(getData());
   }
 
-  FORCE_INLINE VariantRef getOrCreateVariant() const;
+  FORCE_INLINE JsonVariant getOrCreateVariant() const;
 };
 
 }  // namespace ARDUINOJSON_NAMESPACE
diff --git a/src/ArduinoJson/Variant/VariantTo.hpp b/src/ArduinoJson/Variant/VariantTo.hpp
index 6d81edc5..1521d777 100644
--- a/src/ArduinoJson/Variant/VariantTo.hpp
+++ b/src/ArduinoJson/Variant/VariantTo.hpp
@@ -9,10 +9,10 @@
 namespace ARDUINOJSON_NAMESPACE {
 class JsonArray;
 class JsonObject;
-class VariantRef;
+class JsonVariant;
 
 // A metafunction that returns the type of the value returned by
-// VariantRef::to<T>()
+// JsonVariant::to<T>()
 template <typename T>
 struct VariantTo {};
 
@@ -25,8 +25,8 @@ struct VariantTo<JsonObject> {
   typedef JsonObject type;
 };
 template <>
-struct VariantTo<VariantRef> {
-  typedef VariantRef type;
+struct VariantTo<JsonVariant> {
+  typedef JsonVariant type;
 };
 
 }  // namespace ARDUINOJSON_NAMESPACE