Value → Convertible

37 files changed, 154 insertions, 155 deletions

diff --git a/include/mbgl/style/conversion.hpp b/include/mbgl/style/conversion.hpp
index d976e995db..6f5bc5ed69 100644
--- a/include/mbgl/style/conversion.hpp
+++ b/include/mbgl/style/conversion.hpp
@@ -22,13 +22,13 @@ namespace conversion {
    A single template function serves as the public interface:
 
        template <class T>
-       optional<T> convert(const Value& value, Error& error);
+       optional<T> convert(const Convertible& input, Error& error);
 
    Where `T` is one of the above types. If the conversion fails, the result is empty, and the
    error parameter includes diagnostic text suitable for presentation to a library user. Otherwise,
    a filled optional is returned.
 
-   `Value` is a type that encapsulates a special form of polymorphism over various underlying types that
+   `Convertible` is a type that encapsulates a special form of polymorphism over various underlying types that
    can serve as input to the conversion algorithm. For instance, on macOS, we need to support
    conversion from both RapidJSON types, and a JSON structure represented with `NSArray`/`NSDictionary`/etc.
    On Qt, we need to support conversion from RapidJSON types and QVariant.
@@ -40,11 +40,11 @@ namespace conversion {
      * Runtime polymorphism using virtual methods requires extra heap allocation and ubiquitous
        use of std::unique_ptr, unsuitable for this performance-sensitive code.
 
-   Therefore, we're using a custom implementation where we manually create and dispatch through a table
-   of function pointers (vtable), while keeping the storage for any of the possible underlying types inline
-   on the stack.
+   Therefore, we're using a custom implementation of runtime polymorphism where we manually create and
+   dispatch through a table of function pointers (vtable), while keeping the storage for any of the possible
+   underlying types inline on the stack, using `std::aligned_storage`.
 
-   For a given underlying type T, an explicit specialization of ValueTraits<T> must be provided. This
+   For a given underlying type T, an explicit specialization of `ConversionTraits<T>` must be provided. This
    specialization must provide the following static methods:
 
       * `isUndefined(v)` -- returns a boolean indication whether `v` is undefined or a JSON null
@@ -65,32 +65,32 @@ namespace conversion {
       * `toNumber(v)` -- returns `optional<float>`, absence indicating `v` is not a JSON number
       * `toDouble(v)` -- returns `optional<double>`, absence indicating `v` is not a JSON number
       * `toString(v)` -- returns `optional<std::string>`, absence indicating `v` is not a JSON string
-      * `toValue(v)` -- returns `optional<mbgl::Value>`, a variant type, for generic conversion,
+      * `toValue(v)` -- returns `optional<Value>`, a variant type, for generic conversion,
         absence indicating `v` is not a boolean, number, or string. Numbers should be converted to
         unsigned integer, signed integer, or floating point, in descending preference.
 
-   In addition, the type T must be move-constructable. And finally, `Value::Storage`, a typedef for
+   In addition, the type T must be move-constructable. And finally, `Convertible::Storage`, a typedef for
    `std::aligned_storage_t`, must be large enough to satisfy the memory requirements for any of the
    possible underlying types. (A static assert will fail if this is not the case.)
 
-   `Value` itself is movable, but not copyable. A moved-from `Value` is in an invalid state; you must
-   not do anything with it except let it go out of scope.
+   `Convertible` itself is movable, but not copyable. A moved-from `Convertible` is in an invalid state;
+   you must not do anything with it except let it go out of scope.
 */
 
 struct Error { std::string message; };
 
 template <typename T>
-class ValueTraits;
+class ConversionTraits;
 
-class Value {
+class Convertible {
 public:
     template <typename T>
-    Value(const T value) : vtable(vtableForType<T>()) {
+    Convertible(const T value) : vtable(vtableForType<T>()) {
         static_assert(sizeof(Storage) >= sizeof(T), "Storage must be large enough to hold value type");
         new (static_cast<void*>(&storage)) T(value);
    }
 
-    Value(Value&& v)
+    Convertible(Convertible&& v)
         : vtable(v.vtable)
     {
         if (vtable) {
@@ -98,13 +98,13 @@ public:
         }
     }
 
-    ~Value() {
+    ~Convertible() {
         if (vtable) {
             vtable->destroy(storage);
         }
     }
 
-    Value& operator=(Value&& v) {
+    Convertible& operator=(Convertible&& v) {
         if (vtable) {
             vtable->destroy(storage);
         }
@@ -116,71 +116,71 @@ public:
         return *this;
     }
 
-    Value()                        = delete;
-    Value(const Value&)            = delete;
-    Value& operator=(const Value&) = delete;
+    Convertible()                              = delete;
+    Convertible(const Convertible&)            = delete;
+    Convertible& operator=(const Convertible&) = delete;
 
-    friend inline bool isUndefined(const Value& v) {
+    friend inline bool isUndefined(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isUndefined(v.storage);
     }
 
-    friend inline bool isArray(const Value& v) {
+    friend inline bool isArray(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isArray(v.storage);
     }
 
-    friend inline std::size_t arrayLength(const Value& v) {
+    friend inline std::size_t arrayLength(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->arrayLength(v.storage);
     }
 
-    friend inline Value arrayMember(const Value& v, std::size_t i) {
+    friend inline Convertible arrayMember(const Convertible& v, std::size_t i) {
         assert(v.vtable);
         return v.vtable->arrayMember(v.storage, i);
     }
 
-    friend inline bool isObject(const Value& v) {
+    friend inline bool isObject(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isObject(v.storage);
     }
 
-    friend inline optional<Value> objectMember(const Value& v, const char * name) {
+    friend inline optional<Convertible> objectMember(const Convertible& v, const char * name) {
         assert(v.vtable);
         return v.vtable->objectMember(v.storage, name);
     }
 
-    friend inline optional<Error> eachMember(const Value& v, const std::function<optional<Error> (const std::string&, const Value&)>& fn) {
+    friend inline optional<Error> eachMember(const Convertible& v, const std::function<optional<Error> (const std::string&, const Convertible&)>& fn) {
         assert(v.vtable);
         return v.vtable->eachMember(v.storage, fn);
     }
 
-    friend inline optional<bool> toBool(const Value& v) {
+    friend inline optional<bool> toBool(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toBool(v.storage);
     }
 
-    friend inline optional<float> toNumber(const Value& v) {
+    friend inline optional<float> toNumber(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toNumber(v.storage);
     }
 
-    friend inline optional<double> toDouble(const Value& v) {
+    friend inline optional<double> toDouble(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toDouble(v.storage);
     }
 
-    friend inline optional<std::string> toString(const Value& v) {
+    friend inline optional<std::string> toString(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toString(v.storage);
     }
 
-    friend inline optional<mbgl::Value> toValue(const Value& v) {
+    friend inline optional<Value> toValue(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toValue(v.storage);
     }
 
-    friend inline optional<GeoJSON> toGeoJSON(const Value& v, Error& error) {
+    friend inline optional<GeoJSON> toGeoJSON(const Convertible& v, Error& error) {
         assert(v.vtable);
         return v.vtable->toGeoJSON(v.storage, error);
     }
@@ -202,17 +202,17 @@ private:
 
         bool        (*isArray)     (const Storage&);
         std::size_t (*arrayLength) (const Storage&);
-        Value       (*arrayMember) (const Storage&, std::size_t);
+        Convertible (*arrayMember) (const Storage&, std::size_t);
 
-        bool            (*isObject)     (const Storage&);
-        optional<Value> (*objectMember) (const Storage&, const char *);
-        optional<Error> (*eachMember)   (const Storage&, const std::function<optional<Error> (const std::string&, const Value&)>&);
+        bool                  (*isObject)     (const Storage&);
+        optional<Convertible> (*objectMember) (const Storage&, const char *);
+        optional<Error>       (*eachMember)   (const Storage&, const std::function<optional<Error> (const std::string&, const Convertible&)>&);
 
         optional<bool>        (*toBool)   (const Storage&);
         optional<float>       (*toNumber) (const Storage&);
         optional<double>      (*toDouble) (const Storage&);
         optional<std::string> (*toString) (const Storage&);
-        optional<mbgl::Value> (*toValue)  (const Storage&);
+        optional<Value>       (*toValue)  (const Storage&);
 
         // https://github.com/mapbox/mapbox-gl-native/issues/5623
         optional<GeoJSON> (*toGeoJSON) (const Storage&, Error&);
@@ -220,9 +220,8 @@ private:
 
     template <typename T>
     static VTable* vtableForType() {
-        using Traits = ValueTraits<T>;
-    
-        static Value::VTable vtable = {
+        using Traits = ConversionTraits<T>;
+        static VTable vtable = {
             [] (Storage&& src, Storage& dest) {
                 auto srcValue = reinterpret_cast<T&&>(src);
                 new (static_cast<void*>(&dest)) T(std::move(srcValue));
@@ -241,19 +240,19 @@ private:
                 return Traits::arrayLength(reinterpret_cast<const T&>(s));
             },
             [] (const Storage& s, std::size_t i) {
-                return Value(Traits::arrayMember(reinterpret_cast<const T&>(s), i));
+                return Convertible(Traits::arrayMember(reinterpret_cast<const T&>(s), i));
             },
             [] (const Storage& s) {
                 return Traits::isObject(reinterpret_cast<const T&>(s));
             },
             [] (const Storage& s, const char * key) {
                 optional<T> member = Traits::objectMember(reinterpret_cast<const T&>(s), key);
-                if (member) return optional<Value>(*member);
-                return optional<Value>();
+                if (member) return optional<Convertible>(*member);
+                return optional<Convertible>();
             },
-            [] (const Storage& s, const std::function<optional<Error> (const std::string&, const Value&)>& fn) {
+            [] (const Storage& s, const std::function<optional<Error> (const std::string&, const Convertible&)>& fn) {
                 return Traits::eachMember(reinterpret_cast<const T&>(s), [&](const std::string& k, const T& v) {
-                    return fn(k, Value(v));
+                    return fn(k, Convertible(v));
                 });
             },
             [] (const Storage& s) {
@@ -286,7 +285,7 @@ template <class T, class Enable = void>
 struct Converter;
 
 template <class T, class...Args>
-optional<T> convert(const Value& value, Error& error, Args&&...args) {
+optional<T> convert(const Convertible& value, Error& error, Args&&...args) {
     return Converter<T>()(value, error, std::forward<Args>(args)...);
 }
 
diff --git a/include/mbgl/style/conversion/constant.hpp b/include/mbgl/style/conversion/constant.hpp
index 50d31ab9a8..7b3249da52 100644
--- a/include/mbgl/style/conversion/constant.hpp
+++ b/include/mbgl/style/conversion/constant.hpp
@@ -15,22 +15,22 @@ namespace conversion {
 
 template <>
 struct Converter<bool> {
-    optional<bool> operator()(const Value& value, Error& error) const;
+    optional<bool> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<float> {
-    optional<float> operator()(const Value& value, Error& error) const;
+    optional<float> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<std::string> {
-    optional<std::string> operator()(const Value& value, Error& error) const;
+    optional<std::string> operator()(const Convertible& value, Error& error) const;
 };
 
 template <class T>
 struct Converter<T, typename std::enable_if_t<std::is_enum<T>::value>> {
-    optional<T> operator()(const Value& value, Error& error) const {
+    optional<T> operator()(const Convertible& value, Error& error) const {
         optional<std::string> string = toString(value);
         if (!string) {
             error = { "value must be a string" };
@@ -49,12 +49,12 @@ struct Converter<T, typename std::enable_if_t<std::is_enum<T>::value>> {
 
 template <>
 struct Converter<Color> {
-    optional<Color> operator()(const Value& value, Error& error) const;
+    optional<Color> operator()(const Convertible& value, Error& error) const;
 };
 
 template <size_t N>
 struct Converter<std::array<float, N>> {
-    optional<std::array<float, N>> operator()(const Value& value, Error& error) const {
+    optional<std::array<float, N>> operator()(const Convertible& value, Error& error) const {
         if (!isArray(value) || arrayLength(value) != N) {
             error = { "value must be an array of " + util::toString(N) + " numbers" };
             return {};
@@ -75,12 +75,12 @@ struct Converter<std::array<float, N>> {
 
 template <>
 struct Converter<std::vector<float>> {
-    optional<std::vector<float>> operator()(const Value& value, Error& error) const;
+    optional<std::vector<float>> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<std::vector<std::string>> {
-    optional<std::vector<std::string>> operator()(const Value& value, Error& error) const;
+    optional<std::vector<std::string>> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/coordinate.hpp b/include/mbgl/style/conversion/coordinate.hpp
index 8aa39283a8..e11db5e32f 100644
--- a/include/mbgl/style/conversion/coordinate.hpp
+++ b/include/mbgl/style/conversion/coordinate.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template<>
 struct Converter<LatLng> {
 public:
-    optional<LatLng> operator() (const Value& value, Error& error) const;
+    optional<LatLng> operator() (const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index b7e3bef172..1e54c15a49 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -11,7 +11,7 @@ namespace conversion {
 
 template <class T>
 struct Converter<DataDrivenPropertyValue<T>> {
-    optional<DataDrivenPropertyValue<T>> operator()(const Value& value, Error& error) const {
+    optional<DataDrivenPropertyValue<T>> operator()(const Convertible& value, Error& error) const {
         if (isUndefined(value)) {
             return DataDrivenPropertyValue<T>();
         } else if (!isObject(value)) {
diff --git a/include/mbgl/style/conversion/filter.hpp b/include/mbgl/style/conversion/filter.hpp
index d948ad0165..9daf6ea7a4 100644
--- a/include/mbgl/style/conversion/filter.hpp
+++ b/include/mbgl/style/conversion/filter.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Filter> {
 public:
-    optional<Filter> operator()(const Value& value, Error& error) const;
+    optional<Filter> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/function.hpp b/include/mbgl/style/conversion/function.hpp
index 49dfacfef2..e230884944 100644
--- a/include/mbgl/style/conversion/function.hpp
+++ b/include/mbgl/style/conversion/function.hpp
@@ -12,7 +12,7 @@ namespace style {
 namespace conversion {
 
 template <class D, class R>
-optional<std::map<D, R>> convertStops(const Value& value, Error& error) {
+optional<std::map<D, R>> convertStops(const Convertible& value, Error& error) {
     auto stopsValue = objectMember(value, "stops");
     if (!stopsValue) {
         error = { "function value must specify stops" };
@@ -63,7 +63,7 @@ template <class T>
 struct Converter<ExponentialStops<T>> {
     static constexpr const char * type = "exponential";
 
-    optional<ExponentialStops<T>> operator()(const Value& value, Error& error) const {
+    optional<ExponentialStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<float, T>(value, error);
         if (!stops) {
             return {};
@@ -88,7 +88,7 @@ template <class T>
 struct Converter<IntervalStops<T>> {
     static constexpr const char * type = "interval";
 
-    optional<IntervalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<IntervalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<float, T>(value, error);
         if (!stops) {
             return {};
@@ -99,7 +99,7 @@ struct Converter<IntervalStops<T>> {
 
 template <>
 struct Converter<CategoricalValue> {
-    optional<CategoricalValue> operator()(const Value& value, Error& error) const {
+    optional<CategoricalValue> operator()(const Convertible& value, Error& error) const {
         auto b = toBool(value);
         if (b) {
             return { *b };
@@ -124,7 +124,7 @@ template <class T>
 struct Converter<CategoricalStops<T>> {
     static constexpr const char * type = "categorical";
 
-    optional<CategoricalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CategoricalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CategoricalValue, T>(value, error);
         if (!stops) {
             return {};
@@ -138,7 +138,7 @@ template <class T>
 struct Converter<IdentityStops<T>> {
     static constexpr const char * type = "identity";
 
-    optional<IdentityStops<T>> operator()(const Value&, Error&) const {
+    optional<IdentityStops<T>> operator()(const Convertible&, Error&) const {
         return IdentityStops<T>();
     }
 };
@@ -149,7 +149,7 @@ struct StopsConverter;
 template <class T, class... Ts>
 struct StopsConverter<T, variant<Ts...>> {
 public:
-    optional<variant<Ts...>> operator()(const Value& value, Error& error) const {
+    optional<variant<Ts...>> operator()(const Convertible& value, Error& error) const {
         std::string type = util::Interpolatable<T>::value ? "exponential" : "interval";
 
         auto typeValue = objectMember(value, "type");
@@ -187,7 +187,7 @@ public:
 
 template <class T>
 struct Converter<CameraFunction<T>> {
-    optional<CameraFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<CameraFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
@@ -203,7 +203,7 @@ struct Converter<CameraFunction<T>> {
 };
 
 template <class T>
-optional<optional<T>> convertDefaultValue(const Value& value, Error& error) {
+optional<optional<T>> convertDefaultValue(const Convertible& value, Error& error) {
     auto defaultValueValue = objectMember(value, "default");
     if (!defaultValueValue) {
         return optional<T>();
@@ -220,7 +220,7 @@ optional<optional<T>> convertDefaultValue(const Value& value, Error& error) {
 
 template <class T>
 struct Converter<SourceFunction<T>> {
-    optional<SourceFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<SourceFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
@@ -259,7 +259,7 @@ struct CompositeValue : std::pair<float, S> {
 
 template <class S>
 struct Converter<CompositeValue<S>> {
-    optional<CompositeValue<S>> operator()(const Value& value, Error& error) const {
+    optional<CompositeValue<S>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "stop must be an object" };
             return {};
@@ -295,7 +295,7 @@ template <class T>
 struct Converter<CompositeExponentialStops<T>> {
     static constexpr const char * type = "exponential";
 
-    optional<CompositeExponentialStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeExponentialStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<float>, T>(value, error);
         if (!stops) {
             return {};
@@ -320,7 +320,7 @@ template <class T>
 struct Converter<CompositeIntervalStops<T>> {
     static constexpr const char * type = "interval";
 
-    optional<CompositeIntervalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeIntervalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<float>, T>(value, error);
         if (!stops) {
             return {};
@@ -339,7 +339,7 @@ template <class T>
 struct Converter<CompositeCategoricalStops<T>> {
     static constexpr const char * type = "categorical";
 
-    optional<CompositeCategoricalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeCategoricalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<CategoricalValue>, T>(value, error);
         if (!stops) {
             return {};
@@ -356,7 +356,7 @@ struct Converter<CompositeCategoricalStops<T>> {
 
 template <class T>
 struct Converter<CompositeFunction<T>> {
-    optional<CompositeFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
diff --git a/include/mbgl/style/conversion/geojson.hpp b/include/mbgl/style/conversion/geojson.hpp
index ed1e0d5fb0..403c5f953b 100644
--- a/include/mbgl/style/conversion/geojson.hpp
+++ b/include/mbgl/style/conversion/geojson.hpp
@@ -13,7 +13,7 @@ optional<GeoJSON> parseGeoJSON(const std::string&, Error&);
 template <>
 struct Converter<GeoJSON> {
 public:
-    optional<GeoJSON> operator()(const Value&, Error&) const;
+    optional<GeoJSON> operator()(const Convertible&, Error&) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/geojson_options.hpp b/include/mbgl/style/conversion/geojson_options.hpp
index e9a147a5cb..3f625babb6 100644
--- a/include/mbgl/style/conversion/geojson_options.hpp
+++ b/include/mbgl/style/conversion/geojson_options.hpp
@@ -9,7 +9,7 @@ namespace conversion {
 
 template <>
 struct Converter<GeoJSONOptions> {
-    optional<GeoJSONOptions> operator()(const Value& value, Error& error) const;
+    optional<GeoJSONOptions> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/layer.hpp b/include/mbgl/style/conversion/layer.hpp
index 32454bdde4..1c0e2e2f07 100644
--- a/include/mbgl/style/conversion/layer.hpp
+++ b/include/mbgl/style/conversion/layer.hpp
@@ -12,12 +12,12 @@ namespace conversion {
 template <>
 struct Converter<std::unique_ptr<Layer>> {
 public:
-    optional<std::unique_ptr<Layer>> operator()(const Value& value, Error& error) const;
+    optional<std::unique_ptr<Layer>> operator()(const Convertible& value, Error& error) const;
 };
 
-optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Value& value);
-optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Value& value);
-optional<Error> setPaintProperties(Layer& layer, const Value& value);
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Convertible& value);
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Convertible& value);
+optional<Error> setPaintProperties(Layer& layer, const Convertible& value);
 
 } // namespace conversion
 } // namespace style
diff --git a/include/mbgl/style/conversion/light.hpp b/include/mbgl/style/conversion/light.hpp
index 38b6991b56..289fca2e31 100644
--- a/include/mbgl/style/conversion/light.hpp
+++ b/include/mbgl/style/conversion/light.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Light> {
 public:
-    optional<Light> operator()(const Value& value, Error& error) const;
+    optional<Light> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/position.hpp b/include/mbgl/style/conversion/position.hpp
index 167cd31378..044c45862d 100644
--- a/include/mbgl/style/conversion/position.hpp
+++ b/include/mbgl/style/conversion/position.hpp
@@ -9,7 +9,7 @@ namespace conversion {
 
 template <>
 struct Converter<Position> {
-    optional<Position> operator()(const Value& value, Error& error) const;
+    optional<Position> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 3780381b23..c7f971ec91 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -11,7 +11,7 @@ namespace conversion {
 
 template <class T>
 struct Converter<PropertyValue<T>> {
-    optional<PropertyValue<T>> operator()(const Value& value, Error& error) const {
+    optional<PropertyValue<T>> operator()(const Convertible& value, Error& error) const {
         if (isUndefined(value)) {
             return PropertyValue<T>();
         } else if (isObject(value)) {
diff --git a/include/mbgl/style/conversion/source.hpp b/include/mbgl/style/conversion/source.hpp
index 0b9a273eb5..2cf2e36da4 100644
--- a/include/mbgl/style/conversion/source.hpp
+++ b/include/mbgl/style/conversion/source.hpp
@@ -12,7 +12,7 @@ namespace conversion {
 template <>
 struct Converter<std::unique_ptr<Source>> {
 public:
-    optional<std::unique_ptr<Source>> operator()(const Value& value, Error& error, const std::string& id) const;
+    optional<std::unique_ptr<Source>> operator()(const Convertible& value, Error& error, const std::string& id) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/tileset.hpp b/include/mbgl/style/conversion/tileset.hpp
index 25f4f27d81..1fb4acf70d 100644
--- a/include/mbgl/style/conversion/tileset.hpp
+++ b/include/mbgl/style/conversion/tileset.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Tileset> {
 public:
-    optional<Tileset> operator()(const Value& value, Error& error) const;
+    optional<Tileset> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/transition_options.hpp b/include/mbgl/style/conversion/transition_options.hpp
index 173d4a8448..0563f39ac3 100644
--- a/include/mbgl/style/conversion/transition_options.hpp
+++ b/include/mbgl/style/conversion/transition_options.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<TransitionOptions> {
 public:
-    optional<TransitionOptions> operator()(const Value& value, Error& error) const;
+    optional<TransitionOptions> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/platform/android/src/style/android_conversion.hpp b/platform/android/src/style/android_conversion.hpp
index bc067fbc53..9b0ddbb50a 100644
--- a/platform/android/src/style/android_conversion.hpp
+++ b/platform/android/src/style/android_conversion.hpp
@@ -15,7 +15,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<mbgl::android::Value> {
+class ConversionTraits<mbgl::android::Value> {
 public:
     static bool isUndefined(const mbgl::android::Value& value) {
         return value.isNull();
@@ -85,7 +85,7 @@ public:
         }
     }
 
-    static optional<mbgl::Value> toValue(const mbgl::android::Value& value) {
+    static optional<Value> toValue(const mbgl::android::Value& value) {
         if (value.isNull()) {
             return {};
         } else if (value.isBool()) {
@@ -111,7 +111,7 @@ public:
 
 template <class T, class...Args>
 optional<T> convert(const mbgl::android::Value& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/platform/android/src/style/conversion/url_or_tileset.hpp b/platform/android/src/style/conversion/url_or_tileset.hpp
index dae1209697..f2ebce7bd1 100644
--- a/platform/android/src/style/conversion/url_or_tileset.hpp
+++ b/platform/android/src/style/conversion/url_or_tileset.hpp
@@ -20,16 +20,16 @@ namespace android {
 inline variant<std::string, Tileset> convertURLOrTileset(const mbgl::android::Value& value) {
     using namespace mbgl::style::conversion;
 
-    const mbgl::style::conversion::Value converted(value);
-    if (isObject(converted)) {
+    const Convertible convertible(value);
+    if (isObject(convertible)) {
         Error error;
-        optional<Tileset> tileset = convert<Tileset>(converted, error);
+        optional<Tileset> tileset = convert<Tileset>(convertible, error);
         if (!tileset) {
             throw std::logic_error(error.message);
         }
         return { *tileset };
     } else {
-        return { *toString(converted) };
+        return { *toString(convertible) };
     }
 }
 
diff --git a/platform/darwin/src/MGLConversion.h b/platform/darwin/src/MGLConversion.h
index 584438e04c..1edb387a99 100644
--- a/platform/darwin/src/MGLConversion.h
+++ b/platform/darwin/src/MGLConversion.h
@@ -14,7 +14,7 @@ public:
 };
 
 template <>
-class ValueTraits<Holder> {
+class ConversionTraits<Holder> {
 public:
     static bool isUndefined(const Holder& holder) {
         const id value = holder.value;
@@ -140,8 +140,8 @@ private:
     }
 };
 
-inline Value makeValue(const id value) {
-    return {Holder(value)};
+inline Convertible makeConvertible(const id value) {
+    return Convertible(Holder(value));
 }
 
 } // namespace conversion
diff --git a/platform/darwin/src/MGLStyleValue_Private.h b/platform/darwin/src/MGLStyleValue_Private.h
index a6da6017d4..5914e0a2aa 100644
--- a/platform/darwin/src/MGLStyleValue_Private.h
+++ b/platform/darwin/src/MGLStyleValue_Private.h
@@ -126,7 +126,7 @@ public:
         } else if ([value isKindOfClass:[MGLStyleFunction class]]) {
             mbgl::style::conversion::Error error;
             auto result = mbgl::style::conversion::convert<mbgl::style::DataDrivenPropertyValue<MBGLType>>(
-                mbgl::style::conversion::makeValue(toRawStyleSpecValue((MGLStyleFunction<ObjCType> *) value)), error);
+                mbgl::style::conversion::makeConvertible(toRawStyleSpecValue((MGLStyleFunction<ObjCType> *) value)), error);
             NSCAssert(result, @(error.message.c_str()));
             return *result;
         } else {
diff --git a/platform/node/src/node_conversion.hpp b/platform/node/src/node_conversion.hpp
index 7db5b23642..04494eb142 100644
--- a/platform/node/src/node_conversion.hpp
+++ b/platform/node/src/node_conversion.hpp
@@ -16,7 +16,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<v8::Local<v8::Value>> {
+class ConversionTraits<v8::Local<v8::Value>> {
 public:
     static bool isUndefined(const v8::Local<v8::Value>& value) {
         Nan::HandleScope scope;
@@ -105,7 +105,7 @@ public:
         return std::string(*Nan::Utf8String(value));
     }
 
-    static optional<mbgl::Value> toValue(const v8::Local<v8::Value>& value) {
+    static optional<Value> toValue(const v8::Local<v8::Value>& value) {
         if (value->IsFalse()) {
             return { false };
         } else if (value->IsTrue()) {
@@ -137,7 +137,7 @@ public:
 
 template <class T, class...Args>
 optional<T> convert(const v8::Local<v8::Value>& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index bd5ba7b152..ade409048e 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -748,7 +748,7 @@ void NodeMap::SetLayoutProperty(const Nan::FunctionCallbackInfo<v8::Value>& info
         return Nan::ThrowTypeError("Second argument must be a string");
     }
 
-    mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), Value(info[2]));
+    mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), Convertible(info[2]));
     if (error) {
         return Nan::ThrowTypeError(error->message.c_str());
     }
@@ -780,7 +780,7 @@ void NodeMap::SetPaintProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
         return Nan::ThrowTypeError("Second argument must be a string");
     }
 
-    mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), Value(info[2]));
+    mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), Convertible(info[2]));
     if (error) {
         return Nan::ThrowTypeError(error->message.c_str());
     }
diff --git a/platform/qt/src/qt_conversion.hpp b/platform/qt/src/qt_conversion.hpp
index 3f58147ca2..91d5d48c12 100644
--- a/platform/qt/src/qt_conversion.hpp
+++ b/platform/qt/src/qt_conversion.hpp
@@ -14,7 +14,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<QVariant> {
+class ConversionTraits<QVariant> {
 public:
     static bool isUndefined(const QVariant& value) {
         return value.isNull() || !value.isValid();
@@ -105,7 +105,7 @@ public:
         }
     }
 
-    static optional<mbgl::Value> toValue(const QVariant& value) {
+    static optional<Value> toValue(const QVariant& value) {
         if (value.type() == QVariant::Bool) {
             return { value.toBool() };
         } else if (value.type() == QVariant::String) {
@@ -140,7 +140,7 @@ public:
 
 template <class T, class...Args>
 optional<T> convert(const QVariant& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/src/mbgl/style/conversion/constant.cpp b/src/mbgl/style/conversion/constant.cpp
index 43feb3380b..e837c4e70b 100644
--- a/src/mbgl/style/conversion/constant.cpp
+++ b/src/mbgl/style/conversion/constant.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<bool> Converter<bool>::operator()(const Value& value, Error& error) const {
+optional<bool> Converter<bool>::operator()(const Convertible& value, Error& error) const {
     optional<bool> converted = toBool(value);
     if (!converted) {
         error = { "value must be a boolean" };
@@ -13,7 +13,7 @@ optional<bool> Converter<bool>::operator()(const Value& value, Error& error) con
     return *converted;
 }
 
-optional<float> Converter<float>::operator()(const Value& value, Error& error) const {
+optional<float> Converter<float>::operator()(const Convertible& value, Error& error) const {
     optional<float> converted = toNumber(value);
     if (!converted) {
         error = { "value must be a number" };
@@ -22,7 +22,7 @@ optional<float> Converter<float>::operator()(const Value& value, Error& error) c
     return *converted;
 }
 
-optional<std::string> Converter<std::string>::operator()(const Value& value, Error& error) const {
+optional<std::string> Converter<std::string>::operator()(const Convertible& value, Error& error) const {
     optional<std::string> converted = toString(value);
     if (!converted) {
         error = { "value must be a string" };
@@ -31,7 +31,7 @@ optional<std::string> Converter<std::string>::operator()(const Value& value, Err
     return *converted;
 }
 
-optional<Color> Converter<Color>::operator()(const Value& value, Error& error) const {
+optional<Color> Converter<Color>::operator()(const Convertible& value, Error& error) const {
     optional<std::string> string = toString(value);
     if (!string) {
         error = { "value must be a string" };
@@ -47,7 +47,7 @@ optional<Color> Converter<Color>::operator()(const Value& value, Error& error) c
     return *color;
 }
 
-optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Value& value, Error& error) const {
+optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "value must be an array" };
         return {};
@@ -68,7 +68,7 @@ optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Val
     return result;
 }
 
-optional<std::vector<std::string>> Converter<std::vector<std::string>>::operator()(const Value& value, Error& error) const {
+optional<std::vector<std::string>> Converter<std::vector<std::string>>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "value must be an array" };
         return {};
diff --git a/src/mbgl/style/conversion/coordinate.cpp b/src/mbgl/style/conversion/coordinate.cpp
index 4f92a9a963..9b2be3381e 100644
--- a/src/mbgl/style/conversion/coordinate.cpp
+++ b/src/mbgl/style/conversion/coordinate.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<LatLng> Converter<LatLng>::operator() (const Value& value, Error& error) const {
+optional<LatLng> Converter<LatLng>::operator() (const Convertible& value, Error& error) const {
     if (!isArray(value) || arrayLength(value) < 2 ) {
         error = { "coordinate array must contain numeric longitude and latitude values" };
         return {};
diff --git a/src/mbgl/style/conversion/filter.cpp b/src/mbgl/style/conversion/filter.cpp
index f3633d5ff7..bb7bb6ea98 100644
--- a/src/mbgl/style/conversion/filter.cpp
+++ b/src/mbgl/style/conversion/filter.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-static optional<mbgl::Value> normalizeValue(const optional<mbgl::Value>& value, Error& error) {
+static optional<Value> normalizeValue(const optional<Value>& value, Error& error) {
     if (!value) {
         error = { "filter expression value must be a boolean, number, or string" };
         return {};
@@ -14,7 +14,7 @@ static optional<mbgl::Value> normalizeValue(const optional<mbgl::Value>& value,
     }
 }
 
-static optional<FeatureType> toFeatureType(const Value& value, Error& error) {
+static optional<FeatureType> toFeatureType(const Convertible& value, Error& error) {
     optional<std::string> type = toString(value);
     if (!type) {
         error = { "value for $type filter must be a string" };
@@ -31,8 +31,8 @@ static optional<FeatureType> toFeatureType(const Value& value, Error& error) {
     }
 }
 
-static optional<FeatureIdentifier> toFeatureIdentifier(const Value& value, Error& error) {
-    optional<mbgl::Value> identifier = toValue(value);
+static optional<FeatureIdentifier> toFeatureIdentifier(const Convertible& value, Error& error) {
+    optional<Value> identifier = toValue(value);
     if (!identifier) {
         error = { "filter expression value must be a boolean, number, or string" };
         return {};
@@ -50,7 +50,7 @@ static optional<FeatureIdentifier> toFeatureIdentifier(const Value& value, Error
 }
 
 template <class FilterType, class IdentifierFilterType>
-optional<Filter> convertUnaryFilter(const Value& value, Error& error) {
+optional<Filter> convertUnaryFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 2) {
         error = { "filter expression must have 2 elements" };
         return {};
@@ -70,7 +70,7 @@ optional<Filter> convertUnaryFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType, class TypeFilterType, class IdentifierFilterType>
-optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
+optional<Filter> convertEqualityFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 3) {
         error = { "filter expression must have 3 elements" };
         return {};
@@ -99,7 +99,7 @@ optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
         return { IdentifierFilterType { *filterValue } };
 
     } else {
-        optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+        optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
         if (!filterValue) {
             return {};
         }
@@ -109,7 +109,7 @@ optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType>
-optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
+optional<Filter> convertBinaryFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 3) {
         error = { "filter expression must have 3 elements" };
         return {};
@@ -121,7 +121,7 @@ optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
         return {};
     }
 
-    optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+    optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
     if (!filterValue) {
         return {};
     }
@@ -130,7 +130,7 @@ optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType, class TypeFilterType, class IdentifierFilterType>
-optional<Filter> convertSetFilter(const Value& value, Error& error) {
+optional<Filter> convertSetFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 2) {
         error = { "filter expression must at least 2 elements" };
         return {};
@@ -167,9 +167,9 @@ optional<Filter> convertSetFilter(const Value& value, Error& error) {
         return { IdentifierFilterType { std::move(values) } };
 
     } else {
-        std::vector<mbgl::Value> values;
+        std::vector<Value> values;
         for (std::size_t i = 2; i < arrayLength(value); ++i) {
-            optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, i)), error);
+            optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, i)), error);
             if (!filterValue) {
                 return {};
             }
@@ -181,7 +181,7 @@ optional<Filter> convertSetFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType>
-optional<Filter> convertCompoundFilter(const Value& value, Error& error) {
+optional<Filter> convertCompoundFilter(const Convertible& value, Error& error) {
     std::vector<Filter> filters;
     for (std::size_t i = 1; i < arrayLength(value); ++i) {
         optional<Filter> element = convert<Filter>(arrayMember(value, i), error);
@@ -194,7 +194,7 @@ optional<Filter> convertCompoundFilter(const Value& value, Error& error) {
     return { FilterType { std::move(filters) } };
 }
 
-optional<Filter> Converter<Filter>::operator()(const Value& value, Error& error) const {
+optional<Filter> Converter<Filter>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "filter expression must be an array" };
         return {};
diff --git a/src/mbgl/style/conversion/geojson.cpp b/src/mbgl/style/conversion/geojson.cpp
index 3e7188502f..e39a1a80eb 100644
--- a/src/mbgl/style/conversion/geojson.cpp
+++ b/src/mbgl/style/conversion/geojson.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<GeoJSON> Converter<GeoJSON>::operator()(const Value& value, Error& error) const {
+optional<GeoJSON> Converter<GeoJSON>::operator()(const Convertible& value, Error& error) const {
     return toGeoJSON(value, error);
 }
 
diff --git a/src/mbgl/style/conversion/geojson_options.cpp b/src/mbgl/style/conversion/geojson_options.cpp
index e3d4290091..a2c5ed8816 100644
--- a/src/mbgl/style/conversion/geojson_options.cpp
+++ b/src/mbgl/style/conversion/geojson_options.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<GeoJSONOptions> Converter<GeoJSONOptions>::operator()(const Value& value, Error& error) const {
+optional<GeoJSONOptions> Converter<GeoJSONOptions>::operator()(const Convertible& value, Error& error) const {
     GeoJSONOptions options;
 
     const auto minzoomValue = objectMember(value, "minzoom");
diff --git a/src/mbgl/style/conversion/layer.cpp b/src/mbgl/style/conversion/layer.cpp
index 129c39c4ea..0ca582f8dc 100644
--- a/src/mbgl/style/conversion/layer.cpp
+++ b/src/mbgl/style/conversion/layer.cpp
@@ -14,7 +14,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Value& value) {
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Convertible& value) {
     static const auto setters = makeLayoutPropertySetters();
     auto it = setters.find(name);
     if (it == setters.end()) {
@@ -23,7 +23,7 @@ optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const V
     return it->second(layer, value);
 }
 
-optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Value& value) {
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Convertible& value) {
     static const auto setters = makePaintPropertySetters();
     auto it = setters.find(name);
     if (it == setters.end()) {
@@ -32,18 +32,18 @@ optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Va
     return it->second(layer, value);
 }
 
-optional<Error> setPaintProperties(Layer& layer, const Value& value) {
+optional<Error> setPaintProperties(Layer& layer, const Convertible& value) {
     auto paintValue = objectMember(value, "paint");
     if (!paintValue) {
         return {};
     }
-    return eachMember(*paintValue, [&] (const std::string& k, const Value& v) {
+    return eachMember(*paintValue, [&] (const std::string& k, const Convertible& v) {
         return setPaintProperty(layer, k, v);
     });
 }
 
 template <class LayerType>
-optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const Value& value, Error& error) {
+optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const Convertible& value, Error& error) {
     auto sourceValue = objectMember(value, "source");
     if (!sourceValue) {
         error = { "layer must have a source" };
@@ -80,7 +80,7 @@ optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const
     return { std::move(layer) };
 }
 
-static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const Value& value, Error& error) {
+static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const Convertible& value, Error& error) {
     auto sourceValue = objectMember(value, "source");
     if (!sourceValue) {
         error = { "layer must have a source" };
@@ -96,11 +96,11 @@ static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id
     return { std::make_unique<RasterLayer>(id, *source) };
 }
 
-static optional<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const Value&, Error&) {
+static optional<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const Convertible&, Error&) {
     return { std::make_unique<BackgroundLayer>(id) };
 }
 
-optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(const Value& value, Error& error) const {
+optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "layer must be an object" };
         return {};
@@ -183,7 +183,7 @@ optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(c
             error = { "layout must be an object" };
             return {};
         }
-        optional<Error> error_ = eachMember(*layoutValue, [&] (const std::string& k, const Value& v) {
+        optional<Error> error_ = eachMember(*layoutValue, [&] (const std::string& k, const Convertible& v) {
             return setLayoutProperty(*layer, k, v);
         });
         if (error_) {
diff --git a/src/mbgl/style/conversion/light.cpp b/src/mbgl/style/conversion/light.cpp
index f468bddcc1..f521f74386 100644
--- a/src/mbgl/style/conversion/light.cpp
+++ b/src/mbgl/style/conversion/light.cpp
@@ -7,7 +7,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Light> Converter<Light>::operator()(const Value& value, Error& error) const {
+optional<Light> Converter<Light>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "light must be an object" };
         return {};
diff --git a/src/mbgl/style/conversion/position.cpp b/src/mbgl/style/conversion/position.cpp
index fa6619fee3..702d250dbf 100644
--- a/src/mbgl/style/conversion/position.cpp
+++ b/src/mbgl/style/conversion/position.cpp
@@ -7,7 +7,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Position> Converter<Position>::operator()(const Value& value, Error& error) const {
+optional<Position> Converter<Position>::operator()(const Convertible& value, Error& error) const {
     optional<std::array<float, 3>> spherical = convert<std::array<float, 3>>(value, error);
 
     if (!spherical) {
diff --git a/src/mbgl/style/conversion/property_setter.hpp b/src/mbgl/style/conversion/property_setter.hpp
index ef8377fc12..9e382b9c38 100644
--- a/src/mbgl/style/conversion/property_setter.hpp
+++ b/src/mbgl/style/conversion/property_setter.hpp
@@ -13,10 +13,10 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-using PropertySetter = optional<Error> (*) (Layer&, const Value&);
+using PropertySetter = optional<Error> (*) (Layer&, const Convertible&);
 
 template <class L, class PropertyValue, void (L::*setter)(PropertyValue)>
-optional<Error> setProperty(Layer& layer, const Value& value) {
+optional<Error> setProperty(Layer& layer, const Convertible& value) {
     auto* typedLayer = layer.as<L>();
     if (!typedLayer) {
         return Error { "layer doesn't support this property" };
@@ -33,7 +33,7 @@ optional<Error> setProperty(Layer& layer, const Value& value) {
 }
 
 template <class L, void (L::*setter)(const TransitionOptions&)>
-optional<Error> setTransition(Layer& layer, const Value& value) {
+optional<Error> setTransition(Layer& layer, const Convertible& value) {
     auto* typedLayer = layer.as<L>();
     if (!typedLayer) {
         return Error { "layer doesn't support this property" };
@@ -49,7 +49,7 @@ optional<Error> setTransition(Layer& layer, const Value& value) {
     return {};
 }
 
-inline optional<Error> setVisibility(Layer& layer, const Value& value) {
+inline optional<Error> setVisibility(Layer& layer, const Convertible& value) {
     if (isUndefined(value)) {
         layer.setVisibility(VisibilityType::Visible);
         return {};
diff --git a/src/mbgl/style/conversion/source.cpp b/src/mbgl/style/conversion/source.cpp
index f88d33fa4b..c10d0babcf 100644
--- a/src/mbgl/style/conversion/source.cpp
+++ b/src/mbgl/style/conversion/source.cpp
@@ -14,7 +14,7 @@ namespace style {
 namespace conversion {
 
 // A tile source can either specify a URL to TileJSON, or inline TileJSON.
-static optional<variant<std::string, Tileset>> convertURLOrTileset(const Value& value, Error& error) {
+static optional<variant<std::string, Tileset>> convertURLOrTileset(const Convertible& value, Error& error) {
     auto urlVal = objectMember(value, "url");
     if (!urlVal) {
         optional<Tileset> tileset = convert<Tileset>(value, error);
@@ -34,7 +34,7 @@ static optional<variant<std::string, Tileset>> convertURLOrTileset(const Value&
 }
 
 static optional<std::unique_ptr<Source>> convertRasterSource(const std::string& id,
-                                                             const Value& value,
+                                                             const Convertible& value,
                                                              Error& error) {
     optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
     if (!urlOrTileset) {
@@ -56,7 +56,7 @@ static optional<std::unique_ptr<Source>> convertRasterSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertVectorSource(const std::string& id,
-                                                             const Value& value,
+                                                             const Convertible& value,
                                                              Error& error) {
     optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
     if (!urlOrTileset) {
@@ -67,7 +67,7 @@ static optional<std::unique_ptr<Source>> convertVectorSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string& id,
-                                                              const Value& value,
+                                                              const Convertible& value,
                                                               Error& error) {
     auto dataValue = objectMember(value, "data");
     if (!dataValue) {
@@ -99,7 +99,7 @@ static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertImageSource(const std::string& id,
-                                                            const Value& value,
+                                                            const Convertible& value,
                                                             Error& error) {
     auto urlValue = objectMember(value, "url");
     if (!urlValue) {
@@ -138,7 +138,7 @@ static optional<std::unique_ptr<Source>> convertImageSource(const std::string& i
     return { std::move(result) };
 }
 
-optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()(const Value& value, Error& error, const std::string& id) const {
+optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()(const Convertible& value, Error& error, const std::string& id) const {
     if (!isObject(value)) {
         error = { "source must be an object" };
         return {};
diff --git a/src/mbgl/style/conversion/stringify.hpp b/src/mbgl/style/conversion/stringify.hpp
index 42b694c852..6ae6fede42 100644
--- a/src/mbgl/style/conversion/stringify.hpp
+++ b/src/mbgl/style/conversion/stringify.hpp
@@ -98,8 +98,8 @@ void stringify(Writer& writer, const std::unordered_map<std::string, T>& m) {
 }
 
 template <class Writer>
-void stringify(Writer& writer, const mbgl::Value& v) {
-    mbgl::Value::visit(v, [&] (const auto& v_) { stringify(writer, v_); });
+void stringify(Writer& writer, const Value& v) {
+    Value::visit(v, [&] (const auto& v_) { stringify(writer, v_); });
 }
 
 template <class Writer>
diff --git a/src/mbgl/style/conversion/tileset.cpp b/src/mbgl/style/conversion/tileset.cpp
index 54a486cb96..b9383c41b8 100644
--- a/src/mbgl/style/conversion/tileset.cpp
+++ b/src/mbgl/style/conversion/tileset.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Tileset> Converter<Tileset>::operator()(const Value& value, Error& error) const {
+optional<Tileset> Converter<Tileset>::operator()(const Convertible& value, Error& error) const {
     Tileset result;
 
     auto tiles = objectMember(value, "tiles");
diff --git a/src/mbgl/style/conversion/transition_options.cpp b/src/mbgl/style/conversion/transition_options.cpp
index caabe7ec88..8a60c5bfd8 100644
--- a/src/mbgl/style/conversion/transition_options.cpp
+++ b/src/mbgl/style/conversion/transition_options.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<TransitionOptions> Converter<TransitionOptions>::operator()(const Value& value, Error& error) const {
+optional<TransitionOptions> Converter<TransitionOptions>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "transition must be an object" };
         return {};
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index 23901f5dc9..10fce33986 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -258,7 +258,7 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
         }
 
         layer = reference->cloneRef(id);
-        conversion::setPaintProperties(*layer, conversion::Value(&value));
+        conversion::setPaintProperties(*layer, conversion::Convertible(&value));
     } else {
         conversion::Error error;
         optional<std::unique_ptr<Layer>> converted = conversion::convert<std::unique_ptr<Layer>>(value, error);
diff --git a/src/mbgl/style/rapidjson_conversion.hpp b/src/mbgl/style/rapidjson_conversion.hpp
index ae3ead24b0..967f1d829c 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -11,7 +11,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<const JSValue*> {
+class ConversionTraits<const JSValue*> {
 public:
     static bool isUndefined(const JSValue* value) {
         return value->IsNull();
@@ -81,7 +81,7 @@ public:
         return {{ value->GetString(), value->GetStringLength() }};
     }
 
-    static optional<mbgl::Value> toValue(const JSValue* value) {
+    static optional<Value> toValue(const JSValue* value) {
         switch (value->GetType()) {
             case rapidjson::kNullType:
             case rapidjson::kFalseType:
@@ -115,7 +115,7 @@ public:
 
 template <class T, class...Args>
 optional<T> convert(const JSValue& value, Error& error, Args&&...args) {
-    return convert<T>(Value(&value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(&value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion