Replace compile-time polymorphism with runtime polymorphism in the conversion system

17 files changed, 1508 insertions, 82 deletions

diff --git a/src/mbgl/style/conversion/constant.cpp b/src/mbgl/style/conversion/constant.cpp
new file mode 100644
index 0000000000..e837c4e70b
--- /dev/null
+++ b/src/mbgl/style/conversion/constant.cpp
@@ -0,0 +1,94 @@
+#include <mbgl/style/conversion/constant.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+optional<bool> Converter<bool>::operator()(const Convertible& value, Error& error) const {
+    optional<bool> converted = toBool(value);
+    if (!converted) {
+        error = { "value must be a boolean" };
+        return {};
+    }
+    return *converted;
+}
+
+optional<float> Converter<float>::operator()(const Convertible& value, Error& error) const {
+    optional<float> converted = toNumber(value);
+    if (!converted) {
+        error = { "value must be a number" };
+        return {};
+    }
+    return *converted;
+}
+
+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" };
+        return {};
+    }
+    return *converted;
+}
+
+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" };
+        return {};
+    }
+
+    optional<Color> color = Color::parse(*string);
+    if (!color) {
+        error = { "value must be a valid color" };
+        return {};
+    }
+
+    return *color;
+}
+
+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 {};
+    }
+
+    std::vector<float> result;
+    result.reserve(arrayLength(value));
+
+    for (std::size_t i = 0; i < arrayLength(value); ++i) {
+        optional<float> number = toNumber(arrayMember(value, i));
+        if (!number) {
+            error = { "value must be an array of numbers" };
+            return {};
+        }
+        result.push_back(*number);
+    }
+
+    return result;
+}
+
+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 {};
+    }
+
+    std::vector<std::string> result;
+    result.reserve(arrayLength(value));
+
+    for (std::size_t i = 0; i < arrayLength(value); ++i) {
+        optional<std::string> string = toString(arrayMember(value, i));
+        if (!string) {
+            error = { "value must be an array of strings" };
+            return {};
+        }
+        result.push_back(*string);
+    }
+
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/coordinate.cpp b/src/mbgl/style/conversion/coordinate.cpp
new file mode 100644
index 0000000000..9b2be3381e
--- /dev/null
+++ b/src/mbgl/style/conversion/coordinate.cpp
@@ -0,0 +1,29 @@
+#include <mbgl/style/conversion/coordinate.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+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 {};
+    }
+    //Style spec uses GeoJSON convention for specifying coordinates
+    optional<double> latitude = toDouble(arrayMember(value, 1));
+    optional<double> longitude = toDouble(arrayMember(value, 0));
+
+    if (!latitude || !longitude) {
+        error = { "coordinate array must contain numeric longitude and latitude values" };
+        return {};
+    }
+    if (*latitude < -90 || *latitude > 90 ){
+        error = { "coordinate latitude must be between -90 and 90" };
+        return {};
+    }
+    return LatLng(*latitude, *longitude);
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/filter.cpp b/src/mbgl/style/conversion/filter.cpp
new file mode 100644
index 0000000000..bb7bb6ea98
--- /dev/null
+++ b/src/mbgl/style/conversion/filter.cpp
@@ -0,0 +1,248 @@
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/util/geometry.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+static optional<Value> normalizeValue(const optional<Value>& value, Error& error) {
+    if (!value) {
+        error = { "filter expression value must be a boolean, number, or string" };
+        return {};
+    } else {
+        return *value;
+    }
+}
+
+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" };
+        return {};
+    } else if (*type == "Point") {
+        return FeatureType::Point;
+    } else if (*type == "LineString") {
+        return FeatureType::LineString;
+    } else if (*type == "Polygon") {
+        return FeatureType::Polygon;
+    } else {
+        error = { "value for $type filter must be Point, LineString, or Polygon" };
+        return {};
+    }
+}
+
+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 {};
+    } else {
+        return (*identifier).match(
+            [] (uint64_t t) -> optional<FeatureIdentifier> { return { t }; },
+            [] ( int64_t t) -> optional<FeatureIdentifier> { return { t }; },
+            [] (  double t) -> optional<FeatureIdentifier> { return { t }; },
+            [] (const std::string& t) -> optional<FeatureIdentifier> { return { t }; },
+            [&] (const auto&) -> optional<FeatureIdentifier> {
+                error = { "filter expression value must be a boolean, number, or string" };
+                return {};
+            });
+    }
+}
+
+template <class FilterType, class IdentifierFilterType>
+optional<Filter> convertUnaryFilter(const Convertible& value, Error& error) {
+    if (arrayLength(value) < 2) {
+        error = { "filter expression must have 2 elements" };
+        return {};
+    }
+
+    optional<std::string> key = toString(arrayMember(value, 1));
+    if (!key) {
+        error = { "filter expression key must be a string" };
+        return {};
+    }
+
+    if (*key == "$id") {
+        return { IdentifierFilterType {} };
+    } else {
+        return { FilterType { *key } };
+    }
+}
+
+template <class FilterType, class TypeFilterType, class IdentifierFilterType>
+optional<Filter> convertEqualityFilter(const Convertible& value, Error& error) {
+    if (arrayLength(value) < 3) {
+        error = { "filter expression must have 3 elements" };
+        return {};
+    }
+
+    optional<std::string> key = toString(arrayMember(value, 1));
+    if (!key) {
+        error = { "filter expression key must be a string" };
+        return {};
+    }
+
+    if (*key == "$type") {
+        optional<FeatureType> filterValue = toFeatureType(arrayMember(value, 2), error);
+        if (!filterValue) {
+            return {};
+        }
+
+        return { TypeFilterType { *filterValue } };
+
+    } else if (*key == "$id") {
+        optional<FeatureIdentifier> filterValue = toFeatureIdentifier(arrayMember(value, 2), error);
+        if (!filterValue) {
+            return {};
+        }
+
+        return { IdentifierFilterType { *filterValue } };
+
+    } else {
+        optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+        if (!filterValue) {
+            return {};
+        }
+
+        return { FilterType { *key, *filterValue } };
+    }
+}
+
+template <class FilterType>
+optional<Filter> convertBinaryFilter(const Convertible& value, Error& error) {
+    if (arrayLength(value) < 3) {
+        error = { "filter expression must have 3 elements" };
+        return {};
+    }
+
+    optional<std::string> key = toString(arrayMember(value, 1));
+    if (!key) {
+        error = { "filter expression key must be a string" };
+        return {};
+    }
+
+    optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+    if (!filterValue) {
+        return {};
+    }
+
+    return { FilterType { *key, *filterValue } };
+}
+
+template <class FilterType, class TypeFilterType, class IdentifierFilterType>
+optional<Filter> convertSetFilter(const Convertible& value, Error& error) {
+    if (arrayLength(value) < 2) {
+        error = { "filter expression must at least 2 elements" };
+        return {};
+    }
+
+    optional<std::string> key = toString(arrayMember(value, 1));
+    if (!key) {
+        error = { "filter expression key must be a string" };
+        return {};
+    }
+
+    if (*key == "$type") {
+        std::vector<FeatureType> values;
+        for (std::size_t i = 2; i < arrayLength(value); ++i) {
+            optional<FeatureType> filterValue = toFeatureType(arrayMember(value, i), error);
+            if (!filterValue) {
+                return {};
+            }
+            values.push_back(*filterValue);
+        }
+
+        return { TypeFilterType { std::move(values) } };
+
+    } else if (*key == "$id") {
+        std::vector<FeatureIdentifier> values;
+        for (std::size_t i = 2; i < arrayLength(value); ++i) {
+            optional<FeatureIdentifier> filterValue = toFeatureIdentifier(arrayMember(value, i), error);
+            if (!filterValue) {
+                return {};
+            }
+            values.push_back(*filterValue);
+        }
+
+        return { IdentifierFilterType { std::move(values) } };
+
+    } else {
+        std::vector<Value> values;
+        for (std::size_t i = 2; i < arrayLength(value); ++i) {
+            optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, i)), error);
+            if (!filterValue) {
+                return {};
+            }
+            values.push_back(*filterValue);
+        }
+
+        return { FilterType { *key, std::move(values) } };
+    }
+}
+
+template <class FilterType>
+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);
+        if (!element) {
+            return {};
+        }
+        filters.push_back(*element);
+    }
+
+    return { FilterType { std::move(filters) } };
+}
+
+optional<Filter> Converter<Filter>::operator()(const Convertible& value, Error& error) const {
+    if (!isArray(value)) {
+        error = { "filter expression must be an array" };
+        return {};
+    }
+
+    if (arrayLength(value) < 1) {
+        error = { "filter expression must have at least 1 element" };
+        return {};
+    }
+
+    optional<std::string> op = toString(arrayMember(value, 0));
+    if (!op) {
+        error = { "filter operator must be a string" };
+        return {};
+    }
+
+    if (*op == "==") {
+        return convertEqualityFilter<EqualsFilter, TypeEqualsFilter, IdentifierEqualsFilter>(value, error);
+    } else if (*op == "!=") {
+        return convertEqualityFilter<NotEqualsFilter, TypeNotEqualsFilter, IdentifierNotEqualsFilter>(value, error);
+    } else if (*op == ">") {
+        return convertBinaryFilter<GreaterThanFilter>(value, error);
+    } else if (*op == ">=") {
+        return convertBinaryFilter<GreaterThanEqualsFilter>(value, error);
+    } else if (*op == "<") {
+        return convertBinaryFilter<LessThanFilter>(value, error);
+    } else if (*op == "<=") {
+        return convertBinaryFilter<LessThanEqualsFilter>(value, error);
+    } else if (*op == "in") {
+        return convertSetFilter<InFilter, TypeInFilter, IdentifierInFilter>(value, error);
+    } else if (*op == "!in") {
+        return convertSetFilter<NotInFilter, TypeNotInFilter, IdentifierNotInFilter>(value, error);
+    } else if (*op == "all") {
+        return convertCompoundFilter<AllFilter>(value, error);
+    } else if (*op == "any") {
+        return convertCompoundFilter<AnyFilter>(value, error);
+    } else if (*op == "none") {
+        return convertCompoundFilter<NoneFilter>(value, error);
+    } else if (*op == "has") {
+        return convertUnaryFilter<HasFilter, HasIdentifierFilter>(value, error);
+    } else if (*op == "!has") {
+       return convertUnaryFilter<NotHasFilter, NotHasIdentifierFilter>(value, error);
+    }
+
+    error = { R"(filter operator must be one of "==", "!=", ">", ">=", "<", "<=", "in", "!in", "all", "any", "none", "has", or "!has")" };
+    return {};
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/geojson.cpp b/src/mbgl/style/conversion/geojson.cpp
index 8103e9014a..e39a1a80eb 100644
--- a/src/mbgl/style/conversion/geojson.cpp
+++ b/src/mbgl/style/conversion/geojson.cpp
@@ -1,26 +1,16 @@
 #include <mbgl/style/conversion/geojson.hpp>
 #include <mbgl/style/conversion/json.hpp>
-#include <mbgl/util/rapidjson.hpp>
-
-#include <mapbox/geojson.hpp>
-#include <mapbox/geojson/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<GeoJSON> Converter<GeoJSON>::operator()(const std::string& value, Error& error) const {
-    return convertJSON<GeoJSON>(value, error);
+optional<GeoJSON> Converter<GeoJSON>::operator()(const Convertible& value, Error& error) const {
+    return toGeoJSON(value, error);
 }
 
-template <>
-optional<GeoJSON> Converter<GeoJSON>::operator()(const JSValue& value, Error& error) const {
-    try {
-        return mapbox::geojson::convert(value);
-    } catch (const std::exception& ex) {
-        error = { ex.what() };
-        return {};
-    }
+optional<GeoJSON> parseGeoJSON(const std::string& value, Error& error) {
+    return convertJSON<GeoJSON>(value, error);
 }
 
 } // namespace conversion
diff --git a/src/mbgl/style/conversion/geojson_options.cpp b/src/mbgl/style/conversion/geojson_options.cpp
new file mode 100644
index 0000000000..a2c5ed8816
--- /dev/null
+++ b/src/mbgl/style/conversion/geojson_options.cpp
@@ -0,0 +1,85 @@
+#include <mbgl/style/conversion/geojson_options.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+optional<GeoJSONOptions> Converter<GeoJSONOptions>::operator()(const Convertible& value, Error& error) const {
+    GeoJSONOptions options;
+
+    const auto minzoomValue = objectMember(value, "minzoom");
+    if (minzoomValue) {
+        if (toNumber(*minzoomValue)) {
+            options.minzoom = static_cast<uint8_t>(*toNumber(*minzoomValue));
+        } else {
+            error = { "GeoJSON source minzoom value must be a number" };
+            return {};
+        }
+    }
+
+    const auto maxzoomValue = objectMember(value, "maxzoom");
+    if (maxzoomValue) {
+        if (toNumber(*maxzoomValue)) {
+            options.maxzoom = static_cast<uint8_t>(*toNumber(*maxzoomValue));
+        } else {
+            error = { "GeoJSON source maxzoom value must be a number" };
+            return {};
+        }
+    }
+
+    const auto bufferValue = objectMember(value, "buffer");
+    if (bufferValue) {
+        if (toNumber(*bufferValue)) {
+            options.buffer = static_cast<uint16_t>(*toNumber(*bufferValue));
+        } else {
+            error = { "GeoJSON source buffer value must be a number" };
+            return {};
+        }
+    }
+
+    const auto toleranceValue = objectMember(value, "tolerance");
+    if (toleranceValue) {
+        if (toNumber(*toleranceValue)) {
+            options.tolerance = static_cast<double>(*toNumber(*toleranceValue));
+        } else {
+            error = { "GeoJSON source tolerance value must be a number" };
+            return {};
+        }
+    }
+
+    const auto clusterValue = objectMember(value, "cluster");
+    if (clusterValue) {
+        if (toBool(*clusterValue)) {
+            options.cluster = *toBool(*clusterValue);
+        } else {
+            error = { "GeoJSON source cluster value must be a boolean" };
+            return {};
+        }
+    }
+
+    const auto clusterMaxZoomValue = objectMember(value, "clusterMaxZoom");
+    if (clusterMaxZoomValue) {
+        if (toNumber(*clusterMaxZoomValue)) {
+            options.clusterMaxZoom = static_cast<uint8_t>(*toNumber(*clusterMaxZoomValue));
+        } else {
+            error = { "GeoJSON source clusterMaxZoom value must be a number" };
+            return {};
+        }
+    }
+
+    const auto clusterRadiusValue = objectMember(value, "clusterRadius");
+    if (clusterRadiusValue) {
+        if (toNumber(*clusterRadiusValue)) {
+            options.clusterRadius = static_cast<double>(*toNumber(*clusterRadiusValue));
+        } else {
+            error = { "GeoJSON source clusterRadius value must be a number" };
+            return {};
+        }
+    }
+
+    return { options };
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/json.hpp b/src/mbgl/style/conversion/json.hpp
index 0817ac09df..7dd2378f6b 100644
--- a/src/mbgl/style/conversion/json.hpp
+++ b/src/mbgl/style/conversion/json.hpp
@@ -20,7 +20,7 @@ optional<T> convertJSON(const std::string& json, Error& error, Args&&...args) {
         return {};
     }
 
-    return convert<T, JSValue>(document, error, std::forward<Args>(args)...);
+    return convert<T>(document, error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/src/mbgl/style/conversion/layer.cpp b/src/mbgl/style/conversion/layer.cpp
new file mode 100644
index 0000000000..0ca582f8dc
--- /dev/null
+++ b/src/mbgl/style/conversion/layer.cpp
@@ -0,0 +1,206 @@
+#include <mbgl/style/conversion/layer.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/make_property_setters.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+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()) {
+        return Error { "property not found" };
+    }
+    return it->second(layer, 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()) {
+        return Error { "property not found" };
+    }
+    return it->second(layer, 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 Convertible& v) {
+        return setPaintProperty(layer, k, v);
+    });
+}
+
+template <class LayerType>
+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" };
+        return {};
+    }
+
+    optional<std::string> source = toString(*sourceValue);
+    if (!source) {
+        error = { "layer source must be a string" };
+        return {};
+    }
+
+    std::unique_ptr<LayerType> layer = std::make_unique<LayerType>(id, *source);
+
+    auto sourceLayerValue = objectMember(value, "source-layer");
+    if (sourceLayerValue) {
+        optional<std::string> sourceLayer = toString(*sourceLayerValue);
+        if (!sourceLayer) {
+            error = { "layer source-layer must be a string" };
+            return {};
+        }
+        layer->setSourceLayer(*sourceLayer);
+    }
+
+    auto filterValue = objectMember(value, "filter");
+    if (filterValue) {
+        optional<Filter> filter = convert<Filter>(*filterValue, error);
+        if (!filter) {
+            return {};
+        }
+        layer->setFilter(*filter);
+    }
+
+    return { std::move(layer) };
+}
+
+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" };
+        return {};
+    }
+
+    optional<std::string> source = toString(*sourceValue);
+    if (!source) {
+        error = { "layer source must be a string" };
+        return {};
+    }
+
+    return { std::make_unique<RasterLayer>(id, *source) };
+}
+
+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 Convertible& value, Error& error) const {
+    if (!isObject(value)) {
+        error = { "layer must be an object" };
+        return {};
+    }
+
+    auto idValue = objectMember(value, "id");
+    if (!idValue) {
+        error = { "layer must have an id" };
+        return {};
+    }
+
+    optional<std::string> id = toString(*idValue);
+    if (!id) {
+        error = { "layer id must be a string" };
+        return {};
+    }
+
+    auto typeValue = objectMember(value, "type");
+    if (!typeValue) {
+        error = { "layer must have a type" };
+        return {};
+    }
+
+    optional<std::string> type = toString(*typeValue);
+    if (!type) {
+        error = { "layer type must be a string" };
+        return {};
+    }
+
+    optional<std::unique_ptr<Layer>> converted;
+
+    if (*type == "fill") {
+        converted = convertVectorLayer<FillLayer>(*id, value, error);
+    } else if (*type == "fill-extrusion") {
+        converted = convertVectorLayer<FillExtrusionLayer>(*id, value, error);
+    } else if (*type == "line") {
+        converted = convertVectorLayer<LineLayer>(*id, value, error);
+    } else if (*type == "circle") {
+        converted = convertVectorLayer<CircleLayer>(*id, value, error);
+    } else if (*type == "symbol") {
+        converted = convertVectorLayer<SymbolLayer>(*id, value, error);
+    } else if (*type == "raster") {
+        converted = convertRasterLayer(*id, value, error);
+    } else if (*type == "background") {
+        converted = convertBackgroundLayer(*id, value, error);
+    } else {
+        error = { "invalid layer type" };
+        return {};
+    }
+
+    if (!converted) {
+        return converted;
+    }
+
+    std::unique_ptr<Layer> layer = std::move(*converted);
+
+    auto minzoomValue = objectMember(value, "minzoom");
+    if (minzoomValue) {
+        optional<float> minzoom = toNumber(*minzoomValue);
+        if (!minzoom) {
+            error = { "minzoom must be numeric" };
+            return {};
+        }
+        layer->setMinZoom(*minzoom);
+    }
+
+    auto maxzoomValue = objectMember(value, "maxzoom");
+    if (maxzoomValue) {
+        optional<float> maxzoom = toNumber(*maxzoomValue);
+        if (!maxzoom) {
+            error = { "maxzoom must be numeric" };
+            return {};
+        }
+        layer->setMaxZoom(*maxzoom);
+    }
+
+    auto layoutValue = objectMember(value, "layout");
+    if (layoutValue) {
+        if (!isObject(*layoutValue)) {
+            error = { "layout must be an object" };
+            return {};
+        }
+        optional<Error> error_ = eachMember(*layoutValue, [&] (const std::string& k, const Convertible& v) {
+            return setLayoutProperty(*layer, k, v);
+        });
+        if (error_) {
+            error = *error_;
+            return {};
+        }
+    }
+
+    optional<Error> error_ = setPaintProperties(*layer, value);
+    if (error_) {
+        error = *error_;
+        return {};
+    }
+
+    return std::move(layer);
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/light.cpp b/src/mbgl/style/conversion/light.cpp
new file mode 100644
index 0000000000..f521f74386
--- /dev/null
+++ b/src/mbgl/style/conversion/light.cpp
@@ -0,0 +1,115 @@
+#include <mbgl/style/conversion/light.hpp>
+#include <mbgl/style/conversion/position.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+optional<Light> Converter<Light>::operator()(const Convertible& value, Error& error) const {
+    if (!isObject(value)) {
+        error = { "light must be an object" };
+        return {};
+    }
+
+    Light light;
+
+    const auto anchor = objectMember(value, "anchor");
+    if (anchor) {
+        optional<PropertyValue<LightAnchorType>> convertedAnchor =
+            convert<PropertyValue<LightAnchorType>>(*anchor, error);
+
+        if (convertedAnchor) {
+            light.setAnchor(*convertedAnchor);
+        } else {
+            return {};
+        }
+    }
+
+    const auto anchorTransition = objectMember(value, "anchor-transition");
+    if (anchorTransition) {
+        optional<TransitionOptions> transition =
+            convert<TransitionOptions>(*anchorTransition, error);
+        if (transition) {
+            light.setAnchorTransition(*transition);
+        } else {
+            return {};
+        }
+    }
+
+    const auto color = objectMember(value, "color");
+    if (color) {
+        optional<PropertyValue<Color>> convertedColor =
+            convert<PropertyValue<Color>>(*color, error);
+
+        if (convertedColor) {
+            light.setColor(*convertedColor);
+        } else {
+            return {};
+        }
+    }
+
+    const auto colorTransition = objectMember(value, "color-transition");
+    if (colorTransition) {
+        optional<TransitionOptions> transition =
+            convert<TransitionOptions>(*colorTransition, error);
+        if (transition) {
+            light.setColorTransition(*transition);
+        } else {
+            return {};
+        }
+    }
+
+    const auto position = objectMember(value, "position");
+    if (position) {
+        optional<PropertyValue<Position>> convertedPosition =
+            convert<PropertyValue<Position>>(*position, error);
+
+        if (convertedPosition) {
+            light.setPosition(*convertedPosition);
+        } else {
+            return {};
+        }
+    }
+
+    const auto positionTransition = objectMember(value, "position-transition");
+    if (positionTransition) {
+        optional<TransitionOptions> transition =
+            convert<TransitionOptions>(*positionTransition, error);
+        if (transition) {
+            light.setPositionTransition(*transition);
+        } else {
+            return {};
+        }
+    }
+
+    const auto intensity = objectMember(value, "intensity");
+    if (intensity) {
+        optional<PropertyValue<float>> convertedIntensity =
+            convert<PropertyValue<float>>(*intensity, error);
+
+        if (convertedIntensity) {
+            light.setIntensity(*convertedIntensity);
+        } else {
+            return {};
+        }
+    }
+
+    const auto intensityTransition = objectMember(value, "intensity-transition");
+    if (intensityTransition) {
+        optional<TransitionOptions> transition =
+            convert<TransitionOptions>(*intensityTransition, error);
+        if (transition) {
+            light.setIntensityTransition(*transition);
+        } else {
+            return {};
+        }
+    }
+
+    return { std::move(light) };
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/make_property_setters.hpp b/src/mbgl/style/conversion/make_property_setters.hpp
new file mode 100644
index 0000000000..074d7eb730
--- /dev/null
+++ b/src/mbgl/style/conversion/make_property_setters.hpp
@@ -0,0 +1,209 @@
+#pragma once
+
+// This file is generated. Edit make_property_setters.hpp.ejs, then run `make style-code`.
+
+#include <mbgl/style/conversion/property_setter.hpp>
+
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+inline auto makeLayoutPropertySetters() {
+    std::unordered_map<std::string, PropertySetter> result;
+
+    result["visibility"] = &setVisibility;
+
+
+    result["line-cap"] = &setProperty<LineLayer, PropertyValue<LineCapType>, &LineLayer::setLineCap>;
+    result["line-join"] = &setProperty<LineLayer, DataDrivenPropertyValue<LineJoinType>, &LineLayer::setLineJoin>;
+    result["line-miter-limit"] = &setProperty<LineLayer, PropertyValue<float>, &LineLayer::setLineMiterLimit>;
+    result["line-round-limit"] = &setProperty<LineLayer, PropertyValue<float>, &LineLayer::setLineRoundLimit>;
+
+    result["symbol-placement"] = &setProperty<SymbolLayer, PropertyValue<SymbolPlacementType>, &SymbolLayer::setSymbolPlacement>;
+    result["symbol-spacing"] = &setProperty<SymbolLayer, PropertyValue<float>, &SymbolLayer::setSymbolSpacing>;
+    result["symbol-avoid-edges"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setSymbolAvoidEdges>;
+    result["icon-allow-overlap"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setIconAllowOverlap>;
+    result["icon-ignore-placement"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setIconIgnorePlacement>;
+    result["icon-optional"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setIconOptional>;
+    result["icon-rotation-alignment"] = &setProperty<SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setIconRotationAlignment>;
+    result["icon-size"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setIconSize>;
+    result["icon-text-fit"] = &setProperty<SymbolLayer, PropertyValue<IconTextFitType>, &SymbolLayer::setIconTextFit>;
+    result["icon-text-fit-padding"] = &setProperty<SymbolLayer, PropertyValue<std::array<float, 4>>, &SymbolLayer::setIconTextFitPadding>;
+    result["icon-image"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<std::string>, &SymbolLayer::setIconImage>;
+    result["icon-rotate"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setIconRotate>;
+    result["icon-padding"] = &setProperty<SymbolLayer, PropertyValue<float>, &SymbolLayer::setIconPadding>;
+    result["icon-keep-upright"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setIconKeepUpright>;
+    result["icon-offset"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<std::array<float, 2>>, &SymbolLayer::setIconOffset>;
+    result["icon-anchor"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<SymbolAnchorType>, &SymbolLayer::setIconAnchor>;
+    result["icon-pitch-alignment"] = &setProperty<SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setIconPitchAlignment>;
+    result["text-pitch-alignment"] = &setProperty<SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setTextPitchAlignment>;
+    result["text-rotation-alignment"] = &setProperty<SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setTextRotationAlignment>;
+    result["text-field"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<std::string>, &SymbolLayer::setTextField>;
+    result["text-font"] = &setProperty<SymbolLayer, PropertyValue<std::vector<std::string>>, &SymbolLayer::setTextFont>;
+    result["text-size"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextSize>;
+    result["text-max-width"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextMaxWidth>;
+    result["text-line-height"] = &setProperty<SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextLineHeight>;
+    result["text-letter-spacing"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextLetterSpacing>;
+    result["text-justify"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<TextJustifyType>, &SymbolLayer::setTextJustify>;
+    result["text-anchor"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<SymbolAnchorType>, &SymbolLayer::setTextAnchor>;
+    result["text-max-angle"] = &setProperty<SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextMaxAngle>;
+    result["text-rotate"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextRotate>;
+    result["text-padding"] = &setProperty<SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextPadding>;
+    result["text-keep-upright"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setTextKeepUpright>;
+    result["text-transform"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<TextTransformType>, &SymbolLayer::setTextTransform>;
+    result["text-offset"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<std::array<float, 2>>, &SymbolLayer::setTextOffset>;
+    result["text-allow-overlap"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setTextAllowOverlap>;
+    result["text-ignore-placement"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setTextIgnorePlacement>;
+    result["text-optional"] = &setProperty<SymbolLayer, PropertyValue<bool>, &SymbolLayer::setTextOptional>;
+
+
+
+
+
+    return result;
+}
+
+inline auto makePaintPropertySetters() {
+    std::unordered_map<std::string, PropertySetter> result;
+
+    result["fill-antialias"] = &setProperty<FillLayer, PropertyValue<bool>, &FillLayer::setFillAntialias>;
+    result["fill-antialias-transition"] = &setTransition<FillLayer, &FillLayer::setFillAntialiasTransition>;
+    result["fill-opacity"] = &setProperty<FillLayer, DataDrivenPropertyValue<float>, &FillLayer::setFillOpacity>;
+    result["fill-opacity-transition"] = &setTransition<FillLayer, &FillLayer::setFillOpacityTransition>;
+    result["fill-color"] = &setProperty<FillLayer, DataDrivenPropertyValue<Color>, &FillLayer::setFillColor>;
+    result["fill-color-transition"] = &setTransition<FillLayer, &FillLayer::setFillColorTransition>;
+    result["fill-outline-color"] = &setProperty<FillLayer, DataDrivenPropertyValue<Color>, &FillLayer::setFillOutlineColor>;
+    result["fill-outline-color-transition"] = &setTransition<FillLayer, &FillLayer::setFillOutlineColorTransition>;
+    result["fill-translate"] = &setProperty<FillLayer, PropertyValue<std::array<float, 2>>, &FillLayer::setFillTranslate>;
+    result["fill-translate-transition"] = &setTransition<FillLayer, &FillLayer::setFillTranslateTransition>;
+    result["fill-translate-anchor"] = &setProperty<FillLayer, PropertyValue<TranslateAnchorType>, &FillLayer::setFillTranslateAnchor>;
+    result["fill-translate-anchor-transition"] = &setTransition<FillLayer, &FillLayer::setFillTranslateAnchorTransition>;
+    result["fill-pattern"] = &setProperty<FillLayer, PropertyValue<std::string>, &FillLayer::setFillPattern>;
+    result["fill-pattern-transition"] = &setTransition<FillLayer, &FillLayer::setFillPatternTransition>;
+
+    result["line-opacity"] = &setProperty<LineLayer, DataDrivenPropertyValue<float>, &LineLayer::setLineOpacity>;
+    result["line-opacity-transition"] = &setTransition<LineLayer, &LineLayer::setLineOpacityTransition>;
+    result["line-color"] = &setProperty<LineLayer, DataDrivenPropertyValue<Color>, &LineLayer::setLineColor>;
+    result["line-color-transition"] = &setTransition<LineLayer, &LineLayer::setLineColorTransition>;
+    result["line-translate"] = &setProperty<LineLayer, PropertyValue<std::array<float, 2>>, &LineLayer::setLineTranslate>;
+    result["line-translate-transition"] = &setTransition<LineLayer, &LineLayer::setLineTranslateTransition>;
+    result["line-translate-anchor"] = &setProperty<LineLayer, PropertyValue<TranslateAnchorType>, &LineLayer::setLineTranslateAnchor>;
+    result["line-translate-anchor-transition"] = &setTransition<LineLayer, &LineLayer::setLineTranslateAnchorTransition>;
+    result["line-width"] = &setProperty<LineLayer, DataDrivenPropertyValue<float>, &LineLayer::setLineWidth>;
+    result["line-width-transition"] = &setTransition<LineLayer, &LineLayer::setLineWidthTransition>;
+    result["line-gap-width"] = &setProperty<LineLayer, DataDrivenPropertyValue<float>, &LineLayer::setLineGapWidth>;
+    result["line-gap-width-transition"] = &setTransition<LineLayer, &LineLayer::setLineGapWidthTransition>;
+    result["line-offset"] = &setProperty<LineLayer, DataDrivenPropertyValue<float>, &LineLayer::setLineOffset>;
+    result["line-offset-transition"] = &setTransition<LineLayer, &LineLayer::setLineOffsetTransition>;
+    result["line-blur"] = &setProperty<LineLayer, DataDrivenPropertyValue<float>, &LineLayer::setLineBlur>;
+    result["line-blur-transition"] = &setTransition<LineLayer, &LineLayer::setLineBlurTransition>;
+    result["line-dasharray"] = &setProperty<LineLayer, PropertyValue<std::vector<float>>, &LineLayer::setLineDasharray>;
+    result["line-dasharray-transition"] = &setTransition<LineLayer, &LineLayer::setLineDasharrayTransition>;
+    result["line-pattern"] = &setProperty<LineLayer, PropertyValue<std::string>, &LineLayer::setLinePattern>;
+    result["line-pattern-transition"] = &setTransition<LineLayer, &LineLayer::setLinePatternTransition>;
+
+    result["icon-opacity"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setIconOpacity>;
+    result["icon-opacity-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconOpacityTransition>;
+    result["icon-color"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<Color>, &SymbolLayer::setIconColor>;
+    result["icon-color-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconColorTransition>;
+    result["icon-halo-color"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<Color>, &SymbolLayer::setIconHaloColor>;
+    result["icon-halo-color-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconHaloColorTransition>;
+    result["icon-halo-width"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setIconHaloWidth>;
+    result["icon-halo-width-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconHaloWidthTransition>;
+    result["icon-halo-blur"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setIconHaloBlur>;
+    result["icon-halo-blur-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconHaloBlurTransition>;
+    result["icon-translate"] = &setProperty<SymbolLayer, PropertyValue<std::array<float, 2>>, &SymbolLayer::setIconTranslate>;
+    result["icon-translate-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconTranslateTransition>;
+    result["icon-translate-anchor"] = &setProperty<SymbolLayer, PropertyValue<TranslateAnchorType>, &SymbolLayer::setIconTranslateAnchor>;
+    result["icon-translate-anchor-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setIconTranslateAnchorTransition>;
+    result["text-opacity"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextOpacity>;
+    result["text-opacity-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextOpacityTransition>;
+    result["text-color"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<Color>, &SymbolLayer::setTextColor>;
+    result["text-color-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextColorTransition>;
+    result["text-halo-color"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<Color>, &SymbolLayer::setTextHaloColor>;
+    result["text-halo-color-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextHaloColorTransition>;
+    result["text-halo-width"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextHaloWidth>;
+    result["text-halo-width-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextHaloWidthTransition>;
+    result["text-halo-blur"] = &setProperty<SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextHaloBlur>;
+    result["text-halo-blur-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextHaloBlurTransition>;
+    result["text-translate"] = &setProperty<SymbolLayer, PropertyValue<std::array<float, 2>>, &SymbolLayer::setTextTranslate>;
+    result["text-translate-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextTranslateTransition>;
+    result["text-translate-anchor"] = &setProperty<SymbolLayer, PropertyValue<TranslateAnchorType>, &SymbolLayer::setTextTranslateAnchor>;
+    result["text-translate-anchor-transition"] = &setTransition<SymbolLayer, &SymbolLayer::setTextTranslateAnchorTransition>;
+
+    result["circle-radius"] = &setProperty<CircleLayer, DataDrivenPropertyValue<float>, &CircleLayer::setCircleRadius>;
+    result["circle-radius-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleRadiusTransition>;
+    result["circle-color"] = &setProperty<CircleLayer, DataDrivenPropertyValue<Color>, &CircleLayer::setCircleColor>;
+    result["circle-color-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleColorTransition>;
+    result["circle-blur"] = &setProperty<CircleLayer, DataDrivenPropertyValue<float>, &CircleLayer::setCircleBlur>;
+    result["circle-blur-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleBlurTransition>;
+    result["circle-opacity"] = &setProperty<CircleLayer, DataDrivenPropertyValue<float>, &CircleLayer::setCircleOpacity>;
+    result["circle-opacity-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleOpacityTransition>;
+    result["circle-translate"] = &setProperty<CircleLayer, PropertyValue<std::array<float, 2>>, &CircleLayer::setCircleTranslate>;
+    result["circle-translate-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleTranslateTransition>;
+    result["circle-translate-anchor"] = &setProperty<CircleLayer, PropertyValue<TranslateAnchorType>, &CircleLayer::setCircleTranslateAnchor>;
+    result["circle-translate-anchor-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleTranslateAnchorTransition>;
+    result["circle-pitch-scale"] = &setProperty<CircleLayer, PropertyValue<CirclePitchScaleType>, &CircleLayer::setCirclePitchScale>;
+    result["circle-pitch-scale-transition"] = &setTransition<CircleLayer, &CircleLayer::setCirclePitchScaleTransition>;
+    result["circle-pitch-alignment"] = &setProperty<CircleLayer, PropertyValue<AlignmentType>, &CircleLayer::setCirclePitchAlignment>;
+    result["circle-pitch-alignment-transition"] = &setTransition<CircleLayer, &CircleLayer::setCirclePitchAlignmentTransition>;
+    result["circle-stroke-width"] = &setProperty<CircleLayer, DataDrivenPropertyValue<float>, &CircleLayer::setCircleStrokeWidth>;
+    result["circle-stroke-width-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleStrokeWidthTransition>;
+    result["circle-stroke-color"] = &setProperty<CircleLayer, DataDrivenPropertyValue<Color>, &CircleLayer::setCircleStrokeColor>;
+    result["circle-stroke-color-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleStrokeColorTransition>;
+    result["circle-stroke-opacity"] = &setProperty<CircleLayer, DataDrivenPropertyValue<float>, &CircleLayer::setCircleStrokeOpacity>;
+    result["circle-stroke-opacity-transition"] = &setTransition<CircleLayer, &CircleLayer::setCircleStrokeOpacityTransition>;
+
+    result["fill-extrusion-opacity"] = &setProperty<FillExtrusionLayer, PropertyValue<float>, &FillExtrusionLayer::setFillExtrusionOpacity>;
+    result["fill-extrusion-opacity-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionOpacityTransition>;
+    result["fill-extrusion-color"] = &setProperty<FillExtrusionLayer, DataDrivenPropertyValue<Color>, &FillExtrusionLayer::setFillExtrusionColor>;
+    result["fill-extrusion-color-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionColorTransition>;
+    result["fill-extrusion-translate"] = &setProperty<FillExtrusionLayer, PropertyValue<std::array<float, 2>>, &FillExtrusionLayer::setFillExtrusionTranslate>;
+    result["fill-extrusion-translate-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionTranslateTransition>;
+    result["fill-extrusion-translate-anchor"] = &setProperty<FillExtrusionLayer, PropertyValue<TranslateAnchorType>, &FillExtrusionLayer::setFillExtrusionTranslateAnchor>;
+    result["fill-extrusion-translate-anchor-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition>;
+    result["fill-extrusion-pattern"] = &setProperty<FillExtrusionLayer, PropertyValue<std::string>, &FillExtrusionLayer::setFillExtrusionPattern>;
+    result["fill-extrusion-pattern-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionPatternTransition>;
+    result["fill-extrusion-height"] = &setProperty<FillExtrusionLayer, DataDrivenPropertyValue<float>, &FillExtrusionLayer::setFillExtrusionHeight>;
+    result["fill-extrusion-height-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionHeightTransition>;
+    result["fill-extrusion-base"] = &setProperty<FillExtrusionLayer, DataDrivenPropertyValue<float>, &FillExtrusionLayer::setFillExtrusionBase>;
+    result["fill-extrusion-base-transition"] = &setTransition<FillExtrusionLayer, &FillExtrusionLayer::setFillExtrusionBaseTransition>;
+
+    result["raster-opacity"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterOpacity>;
+    result["raster-opacity-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterOpacityTransition>;
+    result["raster-hue-rotate"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterHueRotate>;
+    result["raster-hue-rotate-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterHueRotateTransition>;
+    result["raster-brightness-min"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterBrightnessMin>;
+    result["raster-brightness-min-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterBrightnessMinTransition>;
+    result["raster-brightness-max"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterBrightnessMax>;
+    result["raster-brightness-max-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterBrightnessMaxTransition>;
+    result["raster-saturation"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterSaturation>;
+    result["raster-saturation-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterSaturationTransition>;
+    result["raster-contrast"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterContrast>;
+    result["raster-contrast-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterContrastTransition>;
+    result["raster-fade-duration"] = &setProperty<RasterLayer, PropertyValue<float>, &RasterLayer::setRasterFadeDuration>;
+    result["raster-fade-duration-transition"] = &setTransition<RasterLayer, &RasterLayer::setRasterFadeDurationTransition>;
+
+    result["background-color"] = &setProperty<BackgroundLayer, PropertyValue<Color>, &BackgroundLayer::setBackgroundColor>;
+    result["background-color-transition"] = &setTransition<BackgroundLayer, &BackgroundLayer::setBackgroundColorTransition>;
+    result["background-pattern"] = &setProperty<BackgroundLayer, PropertyValue<std::string>, &BackgroundLayer::setBackgroundPattern>;
+    result["background-pattern-transition"] = &setTransition<BackgroundLayer, &BackgroundLayer::setBackgroundPatternTransition>;
+    result["background-opacity"] = &setProperty<BackgroundLayer, PropertyValue<float>, &BackgroundLayer::setBackgroundOpacity>;
+    result["background-opacity-transition"] = &setTransition<BackgroundLayer, &BackgroundLayer::setBackgroundOpacityTransition>;
+
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/make_property_setters.hpp.ejs b/src/mbgl/style/conversion/make_property_setters.hpp.ejs
new file mode 100644
index 0000000000..2975cb19f2
--- /dev/null
+++ b/src/mbgl/style/conversion/make_property_setters.hpp.ejs
@@ -0,0 +1,46 @@
+#pragma once
+
+// This file is generated. Edit make_property_setters.hpp.ejs, then run `make style-code`.
+
+#include <mbgl/style/conversion/property_setter.hpp>
+
+<% for (const layer of locals.layers) { -%>
+#include <mbgl/style/layers/<%- layer.type.replace('-', '_') %>_layer.hpp>
+<% } -%>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+inline auto makeLayoutPropertySetters() {
+    std::unordered_map<std::string, PropertySetter> result;
+
+    result["visibility"] = &setVisibility;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.layoutProperties) { -%>
+    result["<%- property.name %>"] = &setProperty<<%- camelize(layer.type) %>Layer, <%- propertyValueType(property) %>, &<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>>;
+<% } -%>
+
+<% } -%>
+    return result;
+}
+
+inline auto makePaintPropertySetters() {
+    std::unordered_map<std::string, PropertySetter> result;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.paintProperties) { -%>
+    result["<%- property.name %>"] = &setProperty<<%- camelize(layer.type) %>Layer, <%- propertyValueType(property) %>, &<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>>;
+    result["<%- property.name %>-transition"] = &setTransition<<%- camelize(layer.type) %>Layer, &<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>Transition>;
+<% } -%>
+
+<% } -%>
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/position.cpp b/src/mbgl/style/conversion/position.cpp
new file mode 100644
index 0000000000..702d250dbf
--- /dev/null
+++ b/src/mbgl/style/conversion/position.cpp
@@ -0,0 +1,22 @@
+#include <mbgl/style/conversion/position.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+
+#include <array>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+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) {
+        return {};
+    }
+
+    return Position(*spherical);
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/property_setter.hpp b/src/mbgl/style/conversion/property_setter.hpp
new file mode 100644
index 0000000000..9e382b9c38
--- /dev/null
+++ b/src/mbgl/style/conversion/property_setter.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <mbgl/style/layer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/data_driven_property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+using PropertySetter = optional<Error> (*) (Layer&, const Convertible&);
+
+template <class L, class PropertyValue, void (L::*setter)(PropertyValue)>
+optional<Error> setProperty(Layer& layer, const Convertible& value) {
+    auto* typedLayer = layer.as<L>();
+    if (!typedLayer) {
+        return Error { "layer doesn't support this property" };
+    }
+
+    Error error;
+    optional<PropertyValue> typedValue = convert<PropertyValue>(value, error);
+    if (!typedValue) {
+        return error;
+    }
+
+    (typedLayer->*setter)(*typedValue);
+    return {};
+}
+
+template <class L, void (L::*setter)(const TransitionOptions&)>
+optional<Error> setTransition(Layer& layer, const Convertible& value) {
+    auto* typedLayer = layer.as<L>();
+    if (!typedLayer) {
+        return Error { "layer doesn't support this property" };
+    }
+
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+
+    (typedLayer->*setter)(*transition);
+    return {};
+}
+
+inline optional<Error> setVisibility(Layer& layer, const Convertible& value) {
+    if (isUndefined(value)) {
+        layer.setVisibility(VisibilityType::Visible);
+        return {};
+    }
+
+    Error error;
+    optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+    if (!visibility) {
+        return error;
+    }
+
+    layer.setVisibility(*visibility);
+    return {};
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/source.cpp b/src/mbgl/style/conversion/source.cpp
new file mode 100644
index 0000000000..c10d0babcf
--- /dev/null
+++ b/src/mbgl/style/conversion/source.cpp
@@ -0,0 +1,175 @@
+#include <mbgl/style/conversion/source.hpp>
+#include <mbgl/style/conversion/coordinate.hpp>
+#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/style/conversion/geojson_options.hpp>
+#include <mbgl/style/conversion/tileset.hpp>
+#include <mbgl/style/sources/geojson_source.hpp>
+#include <mbgl/style/sources/raster_source.hpp>
+#include <mbgl/style/sources/vector_source.hpp>
+#include <mbgl/style/sources/image_source.hpp>
+#include <mbgl/util/geo.hpp>
+
+namespace mbgl {
+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 Convertible& value, Error& error) {
+    auto urlVal = objectMember(value, "url");
+    if (!urlVal) {
+        optional<Tileset> tileset = convert<Tileset>(value, error);
+        if (!tileset) {
+            return {};
+        }
+        return { *tileset };
+    }
+
+    optional<std::string> url = toString(*urlVal);
+    if (!url) {
+        error = { "source url must be a string" };
+        return {};
+    }
+
+    return { *url };
+}
+
+static optional<std::unique_ptr<Source>> convertRasterSource(const std::string& id,
+                                                             const Convertible& value,
+                                                             Error& error) {
+    optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
+    if (!urlOrTileset) {
+        return {};
+    }
+
+    uint16_t tileSize = util::tileSize;
+    auto tileSizeValue = objectMember(value, "tileSize");
+    if (tileSizeValue) {
+        optional<float> size = toNumber(*tileSizeValue);
+        if (!size || *size < 0 || *size > std::numeric_limits<uint16_t>::max()) {
+            error = { "invalid tileSize" };
+            return {};
+        }
+        tileSize = *size;
+    }
+
+    return { std::make_unique<RasterSource>(id, std::move(*urlOrTileset), tileSize) };
+}
+
+static optional<std::unique_ptr<Source>> convertVectorSource(const std::string& id,
+                                                             const Convertible& value,
+                                                             Error& error) {
+    optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
+    if (!urlOrTileset) {
+        return {};
+    }
+
+    return { std::make_unique<VectorSource>(id, std::move(*urlOrTileset)) };
+}
+
+static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string& id,
+                                                              const Convertible& value,
+                                                              Error& error) {
+    auto dataValue = objectMember(value, "data");
+    if (!dataValue) {
+        error = { "GeoJSON source must have a data value" };
+        return {};
+    }
+
+    optional<GeoJSONOptions> options = convert<GeoJSONOptions>(value, error);
+    if (!options) {
+        return {};
+    }
+
+    auto result = std::make_unique<GeoJSONSource>(id, *options);
+
+    if (isObject(*dataValue)) {
+        optional<GeoJSON> geoJSON = convert<GeoJSON>(*dataValue, error);
+        if (!geoJSON) {
+            return {};
+        }
+        result->setGeoJSON(std::move(*geoJSON));
+    } else if (toString(*dataValue)) {
+        result->setURL(*toString(*dataValue));
+    } else {
+        error = { "GeoJSON data must be a URL or an object" };
+        return {};
+    }
+
+    return { std::move(result) };
+}
+
+static optional<std::unique_ptr<Source>> convertImageSource(const std::string& id,
+                                                            const Convertible& value,
+                                                            Error& error) {
+    auto urlValue = objectMember(value, "url");
+    if (!urlValue) {
+        error = { "Image source must have a url value" };
+        return {};
+    }
+    
+    auto urlString = toString(*urlValue);
+    if (!urlString) {
+        error = { "Image url must be a URL string" };
+        return {};
+    }
+    
+    auto coordinatesValue = objectMember(value, "coordinates");
+    if (!coordinatesValue) {
+        error = { "Image source must have a coordinates values" };
+        return {};
+    }
+    
+    if (!isArray(*coordinatesValue) || arrayLength(*coordinatesValue) != 4) {
+        error = { "Image coordinates must be an array of four longitude latitude pairs" };
+        return {};
+    }
+    
+    std::array<LatLng, 4> coordinates;
+    for (std::size_t i=0; i < 4; i++) {
+        auto latLng = conversion::convert<LatLng>(arrayMember(*coordinatesValue,i), error);
+        if (!latLng) {
+            return {};
+        }
+        coordinates[i] = *latLng;
+    }
+    auto result = std::make_unique<ImageSource>(id, coordinates);
+    result->setURL(*urlString);
+
+    return { std::move(result) };
+}
+
+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 {};
+    }
+
+    auto typeValue = objectMember(value, "type");
+    if (!typeValue) {
+        error = { "source must have a type" };
+        return {};
+    }
+
+    optional<std::string> type = toString(*typeValue);
+    if (!type) {
+        error = { "source type must be a string" };
+        return {};
+    }
+
+    if (*type == "raster") {
+        return convertRasterSource(id, value, error);
+    } else if (*type == "vector") {
+        return convertVectorSource(id, value, error);
+    } else if (*type == "geojson") {
+        return convertGeoJSONSource(id, value, error);
+    } else if (*type == "image") {
+        return convertImageSource(id, value, error);
+    } else {
+        error = { "invalid source type" };
+        return {};
+    }
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/tileset.cpp b/src/mbgl/style/conversion/tileset.cpp
new file mode 100644
index 0000000000..b9383c41b8
--- /dev/null
+++ b/src/mbgl/style/conversion/tileset.cpp
@@ -0,0 +1,73 @@
+#include <mbgl/style/conversion/tileset.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+optional<Tileset> Converter<Tileset>::operator()(const Convertible& value, Error& error) const {
+    Tileset result;
+
+    auto tiles = objectMember(value, "tiles");
+    if (!tiles) {
+        error = { "source must have tiles" };
+        return {};
+    }
+
+    if (!isArray(*tiles)) {
+        error = { "source tiles must be an array" };
+        return {};
+    }
+
+    for (std::size_t i = 0; i < arrayLength(*tiles); i++) {
+        optional<std::string> urlTemplate = toString(arrayMember(*tiles, i));
+        if (!urlTemplate) {
+            error = { "source tiles member must be a string" };
+            return {};
+        }
+        result.tiles.push_back(std::move(*urlTemplate));
+    }
+
+    auto schemeValue = objectMember(value, "scheme");
+    if (schemeValue) {
+        optional<std::string> scheme = toString(*schemeValue);
+        if (scheme && *scheme == "tms") {
+            result.scheme = Tileset::Scheme::TMS;
+        }
+    }
+
+    auto minzoomValue = objectMember(value, "minzoom");
+    if (minzoomValue) {
+        optional<float> minzoom = toNumber(*minzoomValue);
+        if (!minzoom || *minzoom < 0 || *minzoom > std::numeric_limits<uint8_t>::max()) {
+            error = { "invalid minzoom" };
+            return {};
+        }
+        result.zoomRange.min = *minzoom;
+    }
+
+    auto maxzoomValue = objectMember(value, "maxzoom");
+    if (maxzoomValue) {
+        optional<float> maxzoom = toNumber(*maxzoomValue);
+        if (!maxzoom || *maxzoom < 0 || *maxzoom > std::numeric_limits<uint8_t>::max()) {
+            error = { "invalid maxzoom" };
+            return {};
+        }
+        result.zoomRange.max = *maxzoom;
+    }
+
+    auto attributionValue = objectMember(value, "attribution");
+    if (attributionValue) {
+        optional<std::string> attribution = toString(*attributionValue);
+        if (!attribution) {
+            error = { "source attribution must be a string" };
+            return {};
+        }
+        result.attribution = std::move(*attribution);
+    }
+
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/conversion/transition_options.cpp b/src/mbgl/style/conversion/transition_options.cpp
new file mode 100644
index 0000000000..8a60c5bfd8
--- /dev/null
+++ b/src/mbgl/style/conversion/transition_options.cpp
@@ -0,0 +1,40 @@
+#include <mbgl/style/conversion/transition_options.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+optional<TransitionOptions> Converter<TransitionOptions>::operator()(const Convertible& value, Error& error) const {
+    if (!isObject(value)) {
+        error = { "transition must be an object" };
+        return {};
+    }
+
+    TransitionOptions result;
+
+    auto duration = objectMember(value, "duration");
+    if (duration) {
+        auto number = toNumber(*duration);
+        if (!number) {
+            error = { "duration must be a number" };
+            return {};
+        }
+        result.duration = { std::chrono::milliseconds(int64_t(*number)) };
+    }
+
+    auto delay = objectMember(value, "delay");
+    if (delay) {
+        auto number = toNumber(*delay);
+        if (!number) {
+            error = { "delay must be a number" };
+            return {};
+        }
+        result.delay = { std::chrono::milliseconds(int64_t(*number)) };
+    }
+
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index a83897dbf5..10fce33986 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -1,11 +1,13 @@
 #include <mbgl/style/parser.hpp>
 #include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/rapidjson_conversion.hpp>
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/coordinate.hpp>
 #include <mbgl/style/conversion/source.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/light.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
 
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/string.hpp>
@@ -149,7 +151,7 @@ void Parser::parseSources(const JSValue& value) {
     }
 
     for (const auto& property : value.GetObject()) {
-        std::string id = *conversion::toString(property.name);
+        std::string id { property.name.GetString(), property.name.GetStringLength() };
 
         conversion::Error error;
         optional<std::unique_ptr<Source>> source =
@@ -256,7 +258,7 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
         }
 
         layer = reference->cloneRef(id);
-        conversion::setPaintProperties(*layer, 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 48a764ccb4..79bd9c928b 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -1,103 +1,125 @@
 #pragma once
 
 #include <mbgl/util/rapidjson.hpp>
-#include <mbgl/util/feature.hpp>
 #include <mbgl/style/conversion.hpp>
 
+#include <mapbox/geojson.hpp>
+#include <mapbox/geojson/rapidjson.hpp>
+
 namespace mbgl {
 namespace style {
 namespace conversion {
 
-inline bool isUndefined(const JSValue& value) {
-    return value.IsNull();
-}
-
-inline bool isArray(const JSValue& value) {
-    return value.IsArray();
-}
+template <>
+class ConversionTraits<const JSValue*> {
+public:
+    static bool isUndefined(const JSValue* value) {
+        return value->IsNull();
+    }
 
-inline std::size_t arrayLength(const JSValue& value) {
-    return value.Size();
-}
+    static bool isArray(const JSValue* value) {
+        return value->IsArray();
+    }
 
-inline const JSValue& arrayMember(const JSValue& value, std::size_t i) {
-    return value[rapidjson::SizeType(i)];
-}
+    static std::size_t arrayLength(const JSValue* value) {
+        return value->Size();
+    }
 
-inline bool isObject(const JSValue& value) {
-    return value.IsObject();
-}
+    static const JSValue* arrayMember(const JSValue* value, std::size_t i) {
+        return &(*value)[rapidjson::SizeType(i)];
+    }
 
-inline const JSValue* objectMember(const JSValue& value, const char * name) {
-    if (!value.HasMember(name)) {
-        return nullptr;
+    static bool isObject(const JSValue* value) {
+        return value->IsObject();
     }
-    return &value[name];
-}
 
-template <class Fn>
-optional<Error> eachMember(const JSValue& value, Fn&& fn) {
-    assert(value.IsObject());
-    for (const auto& property : value.GetObject()) {
-        optional<Error> result =
-            fn({ property.name.GetString(), property.name.GetStringLength() }, property.value);
-        if (result) {
-            return result;
+    static optional<const JSValue*> objectMember(const JSValue* value, const char * name) {
+        if (!value->HasMember(name)) {
+            return optional<const JSValue*>();
         }
+        const JSValue* const& member = &(*value)[name];
+        return {member};
     }
-    return {};
-}
 
-inline optional<bool> toBool(const JSValue& value) {
-    if (!value.IsBool()) {
+    template <class Fn>
+    static optional<Error> eachMember(const JSValue* value, Fn&& fn) {
+        assert(value->IsObject());
+        for (const auto& property : value->GetObject()) {
+            optional<Error> result =
+                fn({ property.name.GetString(), property.name.GetStringLength() }, &property.value);
+            if (result) {
+                return result;
+            }
+        }
         return {};
     }
-    return value.GetBool();
-}
 
-inline optional<float> toNumber(const JSValue& value) {
-    if (!value.IsNumber()) {
-        return {};
+    static optional<bool> toBool(const JSValue* value) {
+        if (!value->IsBool()) {
+            return {};
+        }
+        return value->GetBool();
     }
-    return value.GetDouble();
-}
 
-inline optional<double> toDouble(const JSValue& value) {
-    if (!value.IsNumber()) {
-        return {};
+    static optional<float> toNumber(const JSValue* value) {
+        if (!value->IsNumber()) {
+            return {};
+        }
+        return value->GetDouble();
     }
-    return value.GetDouble();
-}
 
-inline optional<std::string> toString(const JSValue& value) {
-    if (!value.IsString()) {
-        return {};
+    static optional<double> toDouble(const JSValue* value) {
+        if (!value->IsNumber()) {
+            return {};
+        }
+        return value->GetDouble();
+    }
+
+    static optional<std::string> toString(const JSValue* value) {
+        if (!value->IsString()) {
+            return {};
+        }
+        return {{ value->GetString(), value->GetStringLength() }};
     }
-    return {{ value.GetString(), value.GetStringLength() }};
-}
 
-inline optional<Value> toValue(const JSValue& value) {
-    switch (value.GetType()) {
-        case rapidjson::kNullType:
-        case rapidjson::kFalseType:
-            return { false };
+    static optional<Value> toValue(const JSValue* value) {
+        switch (value->GetType()) {
+            case rapidjson::kNullType:
+            case rapidjson::kFalseType:
+                return { false };
 
-        case rapidjson::kTrueType:
-            return { true };
+            case rapidjson::kTrueType:
+                return { true };
 
-        case rapidjson::kStringType:
-            return { std::string { value.GetString(), value.GetStringLength() } };
+            case rapidjson::kStringType:
+                return { std::string { value->GetString(), value->GetStringLength() } };
 
-        case rapidjson::kNumberType:
-            if (value.IsUint64()) return { value.GetUint64() };
-            if (value.IsInt64()) return { value.GetInt64() };
-            return { value.GetDouble() };
+            case rapidjson::kNumberType:
+                if (value->IsUint64()) return { value->GetUint64() };
+                if (value->IsInt64()) return { value->GetInt64() };
+                return { value->GetDouble() };
 
-        default:
+            default:
+                return {};
+        }
+    }
+
+    static optional<GeoJSON> toGeoJSON(const JSValue* value, Error& error) {
+        try {
+            return mapbox::geojson::convert(*value);
+        } catch (const std::exception& ex) {
+            error = { ex.what() };
             return {};
+        }
     }
+};
+
+template <class T, class...Args>
+optional<T> convert(const JSValue& value, Error& error, Args&&...args) {
+    return convert<T>(Convertible(&value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
 } // namespace style
 } // namespace mbgl
+