[core, node] Implement bindings for addLayer

83 files changed, 841 insertions, 815 deletions

diff --git a/include/mbgl/style/conversion.hpp b/include/mbgl/style/conversion.hpp
index eff7e293a3..2cb3ced376 100644
--- a/include/mbgl/style/conversion.hpp
+++ b/include/mbgl/style/conversion.hpp
@@ -28,6 +28,8 @@ namespace conversion {
    The implementation of `convert` requires that the following are legal expressions for a value `v`
    of type `const V&`:
 
+      * `isUndefined(v)` -- returns a boolean indication whether `v` is undefined or a JSON null
+
       * `isArray(v)` -- returns a boolean indicating whether `v` represents a JSON array
       * `arrayLength(v)` -- called only if `isArray(v)`; returns a size_t length
       * `arrayMember(v)` -- called only if `isArray(v)`; returns `V` or `V&`
@@ -36,6 +38,9 @@ namespace conversion {
       * `objectMember(v, name)` -- called only if `isObject(v)`; `name` is `const char *`; return value:
          * is true when evaluated in a boolean context iff the named member exists
          * is convertable to a `V` or `V&` when dereferenced
+      * `eachMember(v, [] (const std::string&, const V&) -> optional<Error> {...})` -- called
+         only if `isObject(v)`; calls the provided lambda once for each key and value of the object;
+         short-circuits if any call returns an `Error`
 
       * `toBool(v)` -- returns `optional<bool>`, absence indicating `v` is not a JSON boolean
       * `toNumber(v)` -- returns `optional<float>`, absence indicating `v` is not a JSON number
diff --git a/include/mbgl/style/conversion/layer.hpp b/include/mbgl/style/conversion/layer.hpp
new file mode 100644
index 0000000000..0539dcf9ad
--- /dev/null
+++ b/include/mbgl/style/conversion/layer.hpp
@@ -0,0 +1,208 @@
+#pragma once
+
+#include <mbgl/style/layer.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/line_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/make_property_setters.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const V& value) {
+    static const auto setters = makeLayoutPropertySetters<V>();
+    auto it = setters.find(name);
+    if (it == setters.end()) {
+        return Error { "property not found" };
+    }
+    return it->second(layer, value);
+}
+
+template <class V>
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const V& value, const optional<std::string>& klass) {
+    static const auto setters = makePaintPropertySetters<V>();
+    auto it = setters.find(name);
+    if (it == setters.end()) {
+        return Error { "property not found" };
+    }
+    return it->second(layer, value, klass);
+}
+
+template <class V>
+optional<Error> setPaintProperties(Layer& layer, const V& value) {
+    return eachMember(value, [&] (const std::string& paintName, const V& paintValue) -> optional<Error> {
+        if (paintName.compare(0, 5, "paint") != 0) {
+            return {};
+        }
+
+        optional<std::string> klass;
+        if (paintName.compare(0, 6, "paint.") == 0) {
+            klass = paintName.substr(6);
+        }
+
+        return eachMember(paintValue, [&] (const std::string& k, const V& v) {
+            return setPaintProperty(layer, k, v, klass);
+        });
+    });
+}
+
+template <>
+struct Converter<std::unique_ptr<Layer>> {
+public:
+    template <class V>
+    Result<std::unique_ptr<Layer>> operator()(const V& value) const {
+        if (!isObject(value)) {
+            return Error { "layer must be an object" };
+        }
+
+        auto idValue = objectMember(value, "id");
+        if (!idValue) {
+            return Error { "layer must have an id" };
+        }
+
+        optional<std::string> id = toString(*idValue);
+        if (!id) {
+            return Error { "layer id must be a string" };
+        }
+
+        auto typeValue = objectMember(value, "type");
+        if (!typeValue) {
+            return Error { "layer must have a type" };
+        }
+
+        optional<std::string> type = toString(*typeValue);
+        if (!type) {
+            return Error { "layer type must be a string" };
+        }
+
+        Result<std::unique_ptr<Layer>> converted;
+
+        if (*type == "fill") {
+            converted = convertVectorLayer<FillLayer>(*id, value);
+        } else if (*type == "line") {
+            converted = convertVectorLayer<LineLayer>(*id, value);
+        } else if (*type == "circle") {
+            converted = convertVectorLayer<CircleLayer>(*id, value);
+        } else if (*type == "symbol") {
+            converted = convertVectorLayer<SymbolLayer>(*id, value);
+        } else if (*type == "raster") {
+            converted = convertRasterLayer(*id, value);
+        } else if (*type == "background") {
+            converted = convertBackgroundLayer(*id, value);
+        } else {
+            return Error { "invalid layer type" };
+        }
+
+        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) {
+                return Error { "minzoom must be numeric" };
+            }
+            layer->setMinZoom(*minzoom);
+        }
+
+        auto maxzoomValue = objectMember(value, "maxzoom");
+        if (maxzoomValue) {
+            optional<float> maxzoom = toNumber(*maxzoomValue);
+            if (!maxzoom) {
+                return Error { "maxzoom must be numeric" };
+            }
+            layer->setMaxZoom(*maxzoom);
+        }
+
+        auto layoutValue = objectMember(value, "layout");
+        if (layoutValue) {
+            if (!isObject(*layoutValue)) {
+                return Error { "layout must be an object" };
+            }
+            optional<Error> error = eachMember(*layoutValue, [&] (const std::string& k, const V& v) {
+                return setLayoutProperty(*layer, k, v);
+            });
+            if (error) {
+                return *error;
+            }
+        }
+
+        optional<Error> error = setPaintProperties(*layer, value);
+        if (error) {
+            return *error;
+        }
+
+        return std::move(layer);
+    }
+
+private:
+    template <class LayerType, class V>
+    Result<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const V& value) const {
+        auto sourceValue = objectMember(value, "source");
+        if (!sourceValue) {
+            return Error { "layer must have a source" };
+        }
+
+        optional<std::string> source = toString(*sourceValue);
+        if (!source) {
+            return Error { "layer source must be a string" };
+        }
+
+        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) {
+                return Error { "layer source-layer must be a string" };
+            }
+            layer->setSourceLayer(*sourceLayer);
+        }
+
+        auto filterValue = objectMember(value, "filter");
+        if (filterValue) {
+            Result<Filter> filter = convert<Filter>(*filterValue);
+            if (!filter) {
+                return filter.error();
+            }
+            layer->setFilter(*filter);
+        }
+
+        return std::move(layer);
+    }
+
+    template <class V>
+    Result<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const V& value) const {
+        auto sourceValue = objectMember(value, "source");
+        if (!sourceValue) {
+            return Error { "layer must have a source" };
+        }
+
+        optional<std::string> source = toString(*sourceValue);
+        if (!source) {
+            return Error { "layer source must be a string" };
+        }
+
+        return std::make_unique<RasterLayer>(id, *source);
+    }
+
+    template <class V>
+    Result<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const V&) const {
+        return std::make_unique<BackgroundLayer>(id);
+    }
+};
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/make_property_setters.hpp b/include/mbgl/style/conversion/make_property_setters.hpp
new file mode 100644
index 0000000000..4c0089deaf
--- /dev/null
+++ b/include/mbgl/style/conversion/make_property_setters.hpp
@@ -0,0 +1,133 @@
+// 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/raster_layer.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+auto makeLayoutPropertySetters() {
+    std::unordered_map<std::string, LayoutPropertySetter<V>> result;
+
+    result["visibility"] = &setVisibility<V>;
+
+
+    result["line-cap"] = makePropertySetter<V>(&LineLayer::setLineCap);
+    result["line-join"] = makePropertySetter<V>(&LineLayer::setLineJoin);
+    result["line-miter-limit"] = makePropertySetter<V>(&LineLayer::setLineMiterLimit);
+    result["line-round-limit"] = makePropertySetter<V>(&LineLayer::setLineRoundLimit);
+
+    result["symbol-placement"] = makePropertySetter<V>(&SymbolLayer::setSymbolPlacement);
+    result["symbol-spacing"] = makePropertySetter<V>(&SymbolLayer::setSymbolSpacing);
+    result["symbol-avoid-edges"] = makePropertySetter<V>(&SymbolLayer::setSymbolAvoidEdges);
+    result["icon-allow-overlap"] = makePropertySetter<V>(&SymbolLayer::setIconAllowOverlap);
+    result["icon-ignore-placement"] = makePropertySetter<V>(&SymbolLayer::setIconIgnorePlacement);
+    result["icon-optional"] = makePropertySetter<V>(&SymbolLayer::setIconOptional);
+    result["icon-rotation-alignment"] = makePropertySetter<V>(&SymbolLayer::setIconRotationAlignment);
+    result["icon-size"] = makePropertySetter<V>(&SymbolLayer::setIconSize);
+    result["icon-text-fit"] = makePropertySetter<V>(&SymbolLayer::setIconTextFit);
+    result["icon-text-fit-padding"] = makePropertySetter<V>(&SymbolLayer::setIconTextFitPadding);
+    result["icon-image"] = makePropertySetter<V>(&SymbolLayer::setIconImage);
+    result["icon-rotate"] = makePropertySetter<V>(&SymbolLayer::setIconRotate);
+    result["icon-padding"] = makePropertySetter<V>(&SymbolLayer::setIconPadding);
+    result["icon-keep-upright"] = makePropertySetter<V>(&SymbolLayer::setIconKeepUpright);
+    result["icon-offset"] = makePropertySetter<V>(&SymbolLayer::setIconOffset);
+    result["text-pitch-alignment"] = makePropertySetter<V>(&SymbolLayer::setTextPitchAlignment);
+    result["text-rotation-alignment"] = makePropertySetter<V>(&SymbolLayer::setTextRotationAlignment);
+    result["text-field"] = makePropertySetter<V>(&SymbolLayer::setTextField);
+    result["text-font"] = makePropertySetter<V>(&SymbolLayer::setTextFont);
+    result["text-size"] = makePropertySetter<V>(&SymbolLayer::setTextSize);
+    result["text-max-width"] = makePropertySetter<V>(&SymbolLayer::setTextMaxWidth);
+    result["text-line-height"] = makePropertySetter<V>(&SymbolLayer::setTextLineHeight);
+    result["text-letter-spacing"] = makePropertySetter<V>(&SymbolLayer::setTextLetterSpacing);
+    result["text-justify"] = makePropertySetter<V>(&SymbolLayer::setTextJustify);
+    result["text-anchor"] = makePropertySetter<V>(&SymbolLayer::setTextAnchor);
+    result["text-max-angle"] = makePropertySetter<V>(&SymbolLayer::setTextMaxAngle);
+    result["text-rotate"] = makePropertySetter<V>(&SymbolLayer::setTextRotate);
+    result["text-padding"] = makePropertySetter<V>(&SymbolLayer::setTextPadding);
+    result["text-keep-upright"] = makePropertySetter<V>(&SymbolLayer::setTextKeepUpright);
+    result["text-transform"] = makePropertySetter<V>(&SymbolLayer::setTextTransform);
+    result["text-offset"] = makePropertySetter<V>(&SymbolLayer::setTextOffset);
+    result["text-allow-overlap"] = makePropertySetter<V>(&SymbolLayer::setTextAllowOverlap);
+    result["text-ignore-placement"] = makePropertySetter<V>(&SymbolLayer::setTextIgnorePlacement);
+    result["text-optional"] = makePropertySetter<V>(&SymbolLayer::setTextOptional);
+
+
+
+
+    return result;
+}
+
+template <class V>
+auto makePaintPropertySetters() {
+    std::unordered_map<std::string, PaintPropertySetter<V>> result;
+
+    result["fill-antialias"] = makePropertySetter<V>(&FillLayer::setFillAntialias);
+    result["fill-opacity"] = makePropertySetter<V>(&FillLayer::setFillOpacity);
+    result["fill-color"] = makePropertySetter<V>(&FillLayer::setFillColor);
+    result["fill-outline-color"] = makePropertySetter<V>(&FillLayer::setFillOutlineColor);
+    result["fill-translate"] = makePropertySetter<V>(&FillLayer::setFillTranslate);
+    result["fill-translate-anchor"] = makePropertySetter<V>(&FillLayer::setFillTranslateAnchor);
+    result["fill-pattern"] = makePropertySetter<V>(&FillLayer::setFillPattern);
+
+    result["line-opacity"] = makePropertySetter<V>(&LineLayer::setLineOpacity);
+    result["line-color"] = makePropertySetter<V>(&LineLayer::setLineColor);
+    result["line-translate"] = makePropertySetter<V>(&LineLayer::setLineTranslate);
+    result["line-translate-anchor"] = makePropertySetter<V>(&LineLayer::setLineTranslateAnchor);
+    result["line-width"] = makePropertySetter<V>(&LineLayer::setLineWidth);
+    result["line-gap-width"] = makePropertySetter<V>(&LineLayer::setLineGapWidth);
+    result["line-offset"] = makePropertySetter<V>(&LineLayer::setLineOffset);
+    result["line-blur"] = makePropertySetter<V>(&LineLayer::setLineBlur);
+    result["line-dasharray"] = makePropertySetter<V>(&LineLayer::setLineDasharray);
+    result["line-pattern"] = makePropertySetter<V>(&LineLayer::setLinePattern);
+
+    result["icon-opacity"] = makePropertySetter<V>(&SymbolLayer::setIconOpacity);
+    result["icon-color"] = makePropertySetter<V>(&SymbolLayer::setIconColor);
+    result["icon-halo-color"] = makePropertySetter<V>(&SymbolLayer::setIconHaloColor);
+    result["icon-halo-width"] = makePropertySetter<V>(&SymbolLayer::setIconHaloWidth);
+    result["icon-halo-blur"] = makePropertySetter<V>(&SymbolLayer::setIconHaloBlur);
+    result["icon-translate"] = makePropertySetter<V>(&SymbolLayer::setIconTranslate);
+    result["icon-translate-anchor"] = makePropertySetter<V>(&SymbolLayer::setIconTranslateAnchor);
+    result["text-opacity"] = makePropertySetter<V>(&SymbolLayer::setTextOpacity);
+    result["text-color"] = makePropertySetter<V>(&SymbolLayer::setTextColor);
+    result["text-halo-color"] = makePropertySetter<V>(&SymbolLayer::setTextHaloColor);
+    result["text-halo-width"] = makePropertySetter<V>(&SymbolLayer::setTextHaloWidth);
+    result["text-halo-blur"] = makePropertySetter<V>(&SymbolLayer::setTextHaloBlur);
+    result["text-translate"] = makePropertySetter<V>(&SymbolLayer::setTextTranslate);
+    result["text-translate-anchor"] = makePropertySetter<V>(&SymbolLayer::setTextTranslateAnchor);
+
+    result["circle-radius"] = makePropertySetter<V>(&CircleLayer::setCircleRadius);
+    result["circle-color"] = makePropertySetter<V>(&CircleLayer::setCircleColor);
+    result["circle-blur"] = makePropertySetter<V>(&CircleLayer::setCircleBlur);
+    result["circle-opacity"] = makePropertySetter<V>(&CircleLayer::setCircleOpacity);
+    result["circle-translate"] = makePropertySetter<V>(&CircleLayer::setCircleTranslate);
+    result["circle-translate-anchor"] = makePropertySetter<V>(&CircleLayer::setCircleTranslateAnchor);
+
+    result["raster-opacity"] = makePropertySetter<V>(&RasterLayer::setRasterOpacity);
+    result["raster-hue-rotate"] = makePropertySetter<V>(&RasterLayer::setRasterHueRotate);
+    result["raster-brightness-min"] = makePropertySetter<V>(&RasterLayer::setRasterBrightnessMin);
+    result["raster-brightness-max"] = makePropertySetter<V>(&RasterLayer::setRasterBrightnessMax);
+    result["raster-saturation"] = makePropertySetter<V>(&RasterLayer::setRasterSaturation);
+    result["raster-contrast"] = makePropertySetter<V>(&RasterLayer::setRasterContrast);
+    result["raster-fade-duration"] = makePropertySetter<V>(&RasterLayer::setRasterFadeDuration);
+
+    result["background-color"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundColor);
+    result["background-pattern"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundPattern);
+    result["background-opacity"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundOpacity);
+
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/make_property_setters.hpp.ejs b/include/mbgl/style/conversion/make_property_setters.hpp.ejs
new file mode 100644
index 0000000000..493c68ea31
--- /dev/null
+++ b/include/mbgl/style/conversion/make_property_setters.hpp.ejs
@@ -0,0 +1,45 @@
+// 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 %>_layer.hpp>
+<% } -%>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+auto makeLayoutPropertySetters() {
+    std::unordered_map<std::string, LayoutPropertySetter<V>> result;
+
+    result["visibility"] = &setVisibility<V>;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.layoutProperties) { -%>
+    result["<%- property.name %>"] = makePropertySetter<V>(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
+<% } -%>
+
+<% } -%>
+    return result;
+}
+
+template <class V>
+auto makePaintPropertySetters() {
+    std::unordered_map<std::string, PaintPropertySetter<V>> result;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.paintProperties) { -%>
+    result["<%- property.name %>"] = makePropertySetter<V>(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
+<% } -%>
+
+<% } -%>
+    return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/property_setter.hpp b/include/mbgl/style/conversion/property_setter.hpp
new file mode 100644
index 0000000000..38dd934252
--- /dev/null
+++ b/include/mbgl/style/conversion/property_setter.hpp
@@ -0,0 +1,55 @@
+#include <mbgl/style/layer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+
+#include <functional>
+#include <string>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+using LayoutPropertySetter = std::function<optional<Error> (Layer&, const V&)>;
+
+template <class V>
+using PaintPropertySetter = std::function<optional<Error> (Layer&, const V&, const optional<std::string>&)>;
+
+template <class V, class L, class T, class...Args>
+auto makePropertySetter(void (L::*setter)(PropertyValue<T>, const Args&...args)) {
+    return [setter] (Layer& layer, const V& value, const Args&...args) -> optional<Error> {
+        L* typedLayer = layer.as<L>();
+        if (!typedLayer) {
+            return Error { "layer doesn't support this property" };
+        }
+
+        Result<PropertyValue<T>> typedValue = convert<PropertyValue<T>>(value);
+        if (!typedValue) {
+            return typedValue.error();
+        }
+
+        (typedLayer->*setter)(*typedValue, args...);
+        return {};
+    };
+}
+
+template <class V>
+optional<Error> setVisibility(Layer& layer, const V& value) {
+    if (isUndefined(value)) {
+        layer.setVisibility(VisibilityType::Visible);
+        return {};
+    }
+
+    Result<VisibilityType> visibility = convert<VisibilityType>(value);
+    if (!visibility) {
+        return visibility.error();
+    }
+
+    layer.setVisibility(*visibility);
+    return {};
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 840643abbe..de95b56155 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -13,7 +13,9 @@ template <class T>
 struct Converter<PropertyValue<T>> {
     template <class V>
     Result<PropertyValue<T>> operator()(const V& value) const {
-        if (isObject(value)) {
+        if (isUndefined(value)) {
+            return {};
+        } else if (isObject(value)) {
             Result<Function<T>> function = convert<Function<T>>(value);
             if (!function) {
                 return function.error();
diff --git a/include/mbgl/style/layers/background_layer.hpp b/include/mbgl/style/layers/background_layer.hpp
index 2eb84ee499..ac97ec2e6d 100644
--- a/include/mbgl/style/layers/background_layer.hpp
+++ b/include/mbgl/style/layers/background_layer.hpp
@@ -19,13 +19,13 @@ public:
     // Paint properties
 
     PropertyValue<Color> getBackgroundColor() const;
-    void setBackgroundColor(PropertyValue<Color>);
+    void setBackgroundColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<std::string> getBackgroundPattern() const;
-    void setBackgroundPattern(PropertyValue<std::string>);
+    void setBackgroundPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getBackgroundOpacity() const;
-    void setBackgroundOpacity(PropertyValue<float>);
+    void setBackgroundOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/circle_layer.hpp b/include/mbgl/style/layers/circle_layer.hpp
index 9c2b458d4b..c8d99ab30e 100644
--- a/include/mbgl/style/layers/circle_layer.hpp
+++ b/include/mbgl/style/layers/circle_layer.hpp
@@ -27,22 +27,22 @@ public:
     // Paint properties
 
     PropertyValue<float> getCircleRadius() const;
-    void setCircleRadius(PropertyValue<float>);
+    void setCircleRadius(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getCircleColor() const;
-    void setCircleColor(PropertyValue<Color>);
+    void setCircleColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getCircleBlur() const;
-    void setCircleBlur(PropertyValue<float>);
+    void setCircleBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getCircleOpacity() const;
-    void setCircleOpacity(PropertyValue<float>);
+    void setCircleOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<std::array<float, 2>> getCircleTranslate() const;
-    void setCircleTranslate(PropertyValue<std::array<float, 2>>);
+    void setCircleTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     PropertyValue<TranslateAnchorType> getCircleTranslateAnchor() const;
-    void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>);
+    void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/fill_layer.hpp b/include/mbgl/style/layers/fill_layer.hpp
index 90538dd3ea..e70d67f538 100644
--- a/include/mbgl/style/layers/fill_layer.hpp
+++ b/include/mbgl/style/layers/fill_layer.hpp
@@ -27,25 +27,25 @@ public:
     // Paint properties
 
     PropertyValue<bool> getFillAntialias() const;
-    void setFillAntialias(PropertyValue<bool>);
+    void setFillAntialias(PropertyValue<bool>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getFillOpacity() const;
-    void setFillOpacity(PropertyValue<float>);
+    void setFillOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getFillColor() const;
-    void setFillColor(PropertyValue<Color>);
+    void setFillColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getFillOutlineColor() const;
-    void setFillOutlineColor(PropertyValue<Color>);
+    void setFillOutlineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<std::array<float, 2>> getFillTranslate() const;
-    void setFillTranslate(PropertyValue<std::array<float, 2>>);
+    void setFillTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     PropertyValue<TranslateAnchorType> getFillTranslateAnchor() const;
-    void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>);
+    void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     PropertyValue<std::string> getFillPattern() const;
-    void setFillPattern(PropertyValue<std::string>);
+    void setFillPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs
index 60365be906..aaae30287c 100644
--- a/include/mbgl/style/layers/layer.hpp.ejs
+++ b/include/mbgl/style/layers/layer.hpp.ejs
@@ -54,7 +54,7 @@ public:
 
 <% for (const property of paintProperties) { -%>
     PropertyValue<<%- propertyType(property) %>> get<%- camelize(property.name) %>() const;
-    void set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>>);
+    void set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>>, const optional<std::string>& klass = {});
 
 <% } -%>
     // Private implementation
diff --git a/include/mbgl/style/layers/line_layer.hpp b/include/mbgl/style/layers/line_layer.hpp
index 4ffeee114a..abcb425b96 100644
--- a/include/mbgl/style/layers/line_layer.hpp
+++ b/include/mbgl/style/layers/line_layer.hpp
@@ -43,34 +43,34 @@ public:
     // Paint properties
 
     PropertyValue<float> getLineOpacity() const;
-    void setLineOpacity(PropertyValue<float>);
+    void setLineOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getLineColor() const;
-    void setLineColor(PropertyValue<Color>);
+    void setLineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<std::array<float, 2>> getLineTranslate() const;
-    void setLineTranslate(PropertyValue<std::array<float, 2>>);
+    void setLineTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     PropertyValue<TranslateAnchorType> getLineTranslateAnchor() const;
-    void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>);
+    void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getLineWidth() const;
-    void setLineWidth(PropertyValue<float>);
+    void setLineWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getLineGapWidth() const;
-    void setLineGapWidth(PropertyValue<float>);
+    void setLineGapWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getLineOffset() const;
-    void setLineOffset(PropertyValue<float>);
+    void setLineOffset(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getLineBlur() const;
-    void setLineBlur(PropertyValue<float>);
+    void setLineBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<std::vector<float>> getLineDasharray() const;
-    void setLineDasharray(PropertyValue<std::vector<float>>);
+    void setLineDasharray(PropertyValue<std::vector<float>>, const optional<std::string>& klass = {});
 
     PropertyValue<std::string> getLinePattern() const;
-    void setLinePattern(PropertyValue<std::string>);
+    void setLinePattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/raster_layer.hpp b/include/mbgl/style/layers/raster_layer.hpp
index 372434e46d..dea0c26bf3 100644
--- a/include/mbgl/style/layers/raster_layer.hpp
+++ b/include/mbgl/style/layers/raster_layer.hpp
@@ -22,25 +22,25 @@ public:
     // Paint properties
 
     PropertyValue<float> getRasterOpacity() const;
-    void setRasterOpacity(PropertyValue<float>);
+    void setRasterOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterHueRotate() const;
-    void setRasterHueRotate(PropertyValue<float>);
+    void setRasterHueRotate(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterBrightnessMin() const;
-    void setRasterBrightnessMin(PropertyValue<float>);
+    void setRasterBrightnessMin(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterBrightnessMax() const;
-    void setRasterBrightnessMax(PropertyValue<float>);
+    void setRasterBrightnessMax(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterSaturation() const;
-    void setRasterSaturation(PropertyValue<float>);
+    void setRasterSaturation(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterContrast() const;
-    void setRasterContrast(PropertyValue<float>);
+    void setRasterContrast(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getRasterFadeDuration() const;
-    void setRasterFadeDuration(PropertyValue<float>);
+    void setRasterFadeDuration(PropertyValue<float>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp
index b21c8deaf7..77b63d9b91 100644
--- a/include/mbgl/style/layers/symbol_layer.hpp
+++ b/include/mbgl/style/layers/symbol_layer.hpp
@@ -133,46 +133,46 @@ public:
     // Paint properties
 
     PropertyValue<float> getIconOpacity() const;
-    void setIconOpacity(PropertyValue<float>);
+    void setIconOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getIconColor() const;
-    void setIconColor(PropertyValue<Color>);
+    void setIconColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getIconHaloColor() const;
-    void setIconHaloColor(PropertyValue<Color>);
+    void setIconHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getIconHaloWidth() const;
-    void setIconHaloWidth(PropertyValue<float>);
+    void setIconHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getIconHaloBlur() const;
-    void setIconHaloBlur(PropertyValue<float>);
+    void setIconHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<std::array<float, 2>> getIconTranslate() const;
-    void setIconTranslate(PropertyValue<std::array<float, 2>>);
+    void setIconTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     PropertyValue<TranslateAnchorType> getIconTranslateAnchor() const;
-    void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>);
+    void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getTextOpacity() const;
-    void setTextOpacity(PropertyValue<float>);
+    void setTextOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getTextColor() const;
-    void setTextColor(PropertyValue<Color>);
+    void setTextColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<Color> getTextHaloColor() const;
-    void setTextHaloColor(PropertyValue<Color>);
+    void setTextHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getTextHaloWidth() const;
-    void setTextHaloWidth(PropertyValue<float>);
+    void setTextHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<float> getTextHaloBlur() const;
-    void setTextHaloBlur(PropertyValue<float>);
+    void setTextHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     PropertyValue<std::array<float, 2>> getTextTranslate() const;
-    void setTextTranslate(PropertyValue<std::array<float, 2>>);
+    void setTextTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     PropertyValue<TranslateAnchorType> getTextTranslateAnchor() const;
-    void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>);
+    void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/package.json b/package.json
index 592559175f..97edceb9c9 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
     "express": "^4.11.1",
     "mapbox-gl-shaders": "mapbox/mapbox-gl-shaders#59e998295d548f208ee3ec10cdd21ff2630e2079",
     "mapbox-gl-style-spec": "mapbox/mapbox-gl-style-spec#194fc55b6a7dd54c1e2cf2dd9048fbb5e836716d",
-    "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#9a7de2fb72607be6ffa0040bf3d84651719a45e3",
+    "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#1633d164231dddf006777366de82178bf34fe866",
     "node-gyp": "^3.3.1",
     "request": "^2.72.0",
     "tape": "^4.5.1"
diff --git a/platform/node/src/node_conversion.hpp b/platform/node/src/node_conversion.hpp
index 03c13b5846..2418a7a6e4 100644
--- a/platform/node/src/node_conversion.hpp
+++ b/platform/node/src/node_conversion.hpp
@@ -8,11 +8,17 @@
 
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/feature.hpp>
+#include <mbgl/style/conversion.hpp>
 
 namespace mbgl {
 namespace style {
 namespace conversion {
 
+inline bool isUndefined(v8::Local<v8::Value> value) {
+    Nan::HandleScope scope;
+    return value->IsUndefined() || value->IsNull();
+}
+
 inline bool isArray(v8::Local<v8::Value> value) {
     Nan::HandleScope scope;
     return value->IsArray();
@@ -35,16 +41,31 @@ inline bool isObject(v8::Local<v8::Value> value) {
 
 inline optional<v8::Local<v8::Value>> objectMember(v8::Local<v8::Value> value, const char * name) {
     Nan::EscapableHandleScope scope;
-    if (!Nan::Has(value.As<v8::Array>(), Nan::New(name).ToLocalChecked()).FromJust()) {
+    if (!Nan::Has(value->ToObject(), Nan::New(name).ToLocalChecked()).FromJust()) {
         return {};
     }
-    Nan::MaybeLocal<v8::Value> result = Nan::Get(value.As<v8::Array>(), Nan::New(name).ToLocalChecked());
+    Nan::MaybeLocal<v8::Value> result = Nan::Get(value->ToObject(), Nan::New(name).ToLocalChecked());
     if (result.IsEmpty()) {
         return {};
     }
     return scope.Escape(result.ToLocalChecked());
 }
 
+template <class Fn>
+optional<Error> eachMember(v8::Local<v8::Value> value, Fn&& fn) {
+    Nan::HandleScope scope;
+    v8::Local<v8::Array> names = value->ToObject()->GetOwnPropertyNames();
+    for (uint32_t i = 0; i < names->Length(); ++i) {
+        v8::Local<v8::Value> k = Nan::Get(names, i).ToLocalChecked();
+        v8::Local<v8::Value> v = Nan::Get(value->ToObject(), k).ToLocalChecked();
+        optional<Error> result = fn(*Nan::Utf8String(k), v);
+        if (result) {
+            return result;
+        }
+    }
+    return {};
+}
+
 inline optional<bool> toBool(v8::Local<v8::Value> value) {
     Nan::HandleScope scope;
     if (!value->IsBoolean()) {
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index e6ee84ee53..c73d3850f2 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -1,12 +1,12 @@
 #include "node_map.hpp"
 #include "node_request.hpp"
 #include "node_feature.hpp"
-#include "node_style_properties.hpp"
+#include "node_conversion.hpp"
 
 #include <mbgl/platform/default/headless_display.hpp>
 #include <mbgl/util/exception.hpp>
-#include <mbgl/style/layer.hpp>
-#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/conversion/layer.hpp>
+#include <mbgl/style/conversion/filter.hpp>
 
 #include <unistd.h>
 
@@ -56,6 +56,7 @@ NAN_MODULE_INIT(NodeMap::Init) {
     Nan::SetPrototypeMethod(tpl, "release", Release);
 
     Nan::SetPrototypeMethod(tpl, "addClass", AddClass);
+    Nan::SetPrototypeMethod(tpl, "addLayer", AddLayer);
     Nan::SetPrototypeMethod(tpl, "setLayoutProperty", SetLayoutProperty);
     Nan::SetPrototypeMethod(tpl, "setPaintProperty", SetPaintProperty);
     Nan::SetPrototypeMethod(tpl, "setFilter", SetFilter);
@@ -483,7 +484,30 @@ NAN_METHOD(NodeMap::AddClass) {
     info.GetReturnValue().SetUndefined();
 }
 
-void NodeMap::setProperty(const Nan::FunctionCallbackInfo<v8::Value>& info, const PropertySetters& setters) {
+NAN_METHOD(NodeMap::AddLayer) {
+    using namespace mbgl::style;
+    using namespace mbgl::style::conversion;
+
+    auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
+    if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
+
+    if (info.Length() != 1) {
+        return Nan::ThrowTypeError("One argument required");
+    }
+
+    Result<std::unique_ptr<Layer>> layer = convert<std::unique_ptr<Layer>>(info[0]);
+    if (!layer) {
+        Nan::ThrowTypeError(layer.error().message);
+        return;
+    }
+
+    nodeMap->map->addLayer(std::move(*layer));
+}
+
+NAN_METHOD(NodeMap::SetLayoutProperty) {
+    using namespace mbgl::style;
+    using namespace mbgl::style::conversion;
+
     auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
     if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
 
@@ -504,30 +528,57 @@ void NodeMap::setProperty(const Nan::FunctionCallbackInfo<v8::Value>& info, cons
         return Nan::ThrowTypeError("Second argument must be a string");
     }
 
-    auto it = setters.find(*Nan::Utf8String(info[1]));
-    if (it == setters.end()) {
-        return Nan::ThrowTypeError("property not found");
-    }
-
-    if (!it->second(*layer, info[2])) {
-        return;
+    mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), info[2]);
+    if (error) {
+        return Nan::ThrowTypeError(error->message);
     }
 
     nodeMap->map->update(mbgl::Update::RecalculateStyle);
     info.GetReturnValue().SetUndefined();
 }
 
-NAN_METHOD(NodeMap::SetLayoutProperty) {
-    static const PropertySetters setters = makeLayoutPropertySetters();
-    setProperty(info, setters);
-}
-
 NAN_METHOD(NodeMap::SetPaintProperty) {
-    static const PropertySetters setters = makePaintPropertySetters();
-    setProperty(info, setters);
+    using namespace mbgl::style;
+    using namespace mbgl::style::conversion;
+
+    auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
+    if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
+
+    if (info.Length() < 3) {
+        return Nan::ThrowTypeError("Three arguments required");
+    }
+
+    if (!info[0]->IsString()) {
+        return Nan::ThrowTypeError("First argument must be a string");
+    }
+
+    mbgl::style::Layer* layer = nodeMap->map->getLayer(*Nan::Utf8String(info[0]));
+    if (!layer) {
+        return Nan::ThrowTypeError("layer not found");
+    }
+
+    if (!info[1]->IsString()) {
+        return Nan::ThrowTypeError("Second argument must be a string");
+    }
+
+    mbgl::optional<std::string> klass;
+    if (info.Length() == 4 && info[3]->IsString()) {
+        klass = std::string(*Nan::Utf8String(info[3]));
+    }
+
+    mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), info[2], klass);
+    if (error) {
+        return Nan::ThrowTypeError(error->message);
+    }
+
+    nodeMap->map->update(mbgl::Update::RecalculateStyle);
+    info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(NodeMap::SetFilter) {
+    using namespace mbgl::style;
+    using namespace mbgl::style::conversion;
+
     auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
     if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
 
@@ -544,23 +595,39 @@ NAN_METHOD(NodeMap::SetFilter) {
         return Nan::ThrowTypeError("layer not found");
     }
 
-    mbgl::style::Filter filter;
+    Filter filter;
 
     if (!info[1]->IsNull() && !info[1]->IsUndefined()) {
-        mbgl::style::conversion::Result<mbgl::style::Filter> converted
-            = mbgl::style::conversion::convertFilter(info[1]);
-        if (converted.is<mbgl::style::conversion::Error>()) {
-            Nan::ThrowTypeError(converted.get<mbgl::style::conversion::Error>().message);
+        Result<Filter> converted = convert<Filter>(info[1]);
+        if (!converted) {
+            Nan::ThrowTypeError(converted.error().message);
             return;
         }
-        filter = std::move(converted.get<mbgl::style::Filter>());
+        filter = std::move(*converted);
     }
 
-    if (!setFilter(*layer, filter)) {
+    if (layer->is<FillLayer>()) {
+        layer->as<FillLayer>()->setFilter(filter);
+        info.GetReturnValue().SetUndefined();
+        return;
+    }
+    if (layer->is<LineLayer>()) {
+        layer->as<LineLayer>()->setFilter(filter);
+        info.GetReturnValue().SetUndefined();
+        return;
+    }
+    if (layer->is<SymbolLayer>()) {
+        layer->as<SymbolLayer>()->setFilter(filter);
+        info.GetReturnValue().SetUndefined();
+        return;
+    }
+    if (layer->is<CircleLayer>()) {
+        layer->as<CircleLayer>()->setFilter(filter);
+        info.GetReturnValue().SetUndefined();
         return;
     }
 
-    info.GetReturnValue().SetUndefined();
+    Nan::ThrowTypeError("layer doesn't support filters");
 }
 
 NAN_METHOD(NodeMap::DumpDebugLogs) {
diff --git a/platform/node/src/node_map.hpp b/platform/node/src/node_map.hpp
index 58773e33da..8e4b073134 100644
--- a/platform/node/src/node_map.hpp
+++ b/platform/node/src/node_map.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "node_style.hpp"
-
 #include <mbgl/map/map.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/platform/default/headless_view.hpp>
@@ -28,14 +26,13 @@ public:
     static NAN_METHOD(Render);
     static NAN_METHOD(Release);
     static NAN_METHOD(AddClass);
+    static NAN_METHOD(AddLayer);
     static NAN_METHOD(SetLayoutProperty);
     static NAN_METHOD(SetPaintProperty);
     static NAN_METHOD(SetFilter);
     static NAN_METHOD(DumpDebugLogs);
     static NAN_METHOD(QueryRenderedFeatures);
 
-    static void setProperty(const Nan::FunctionCallbackInfo<v8::Value>&, const PropertySetters&);
-
     void startRender(RenderOptions options);
     void renderFinished();
 
diff --git a/platform/node/src/node_style.hpp b/platform/node/src/node_style.hpp
deleted file mode 100644
index 9befd00d10..0000000000
--- a/platform/node/src/node_style.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-#include "node_conversion.hpp"
-
-#include <mbgl/style/layer.hpp>
-#include <mbgl/style/conversion.hpp>
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wshadow"
-#include <nan.h>
-#pragma GCC diagnostic pop
-
-#include <functional>
-#include <string>
-#include <unordered_map>
-
-namespace node_mbgl {
-
-using PropertySetter = std::function<bool (mbgl::style::Layer&, const v8::Local<v8::Value>&)>;
-using PropertySetters = std::unordered_map<std::string, PropertySetter>;
-
-template <class L, class V>
-PropertySetter makePropertySetter(void (L::*setter)(mbgl::style::PropertyValue<V>)) {
-    return [setter] (mbgl::style::Layer& layer, const v8::Local<v8::Value>& value) {
-        L* typedLayer = layer.as<L>();
-        if (!typedLayer) {
-            Nan::ThrowTypeError("layer doesn't support this property");
-            return false;
-        }
-
-        if (value->IsNull() || value->IsUndefined()) {
-            (typedLayer->*setter)(mbgl::style::PropertyValue<V>());
-            return true;
-        }
-
-        mbgl::style::conversion::Result<mbgl::style::PropertyValue<V>> typedValue
-            = mbgl::style::conversion::convertPropertyValue<V>(value);
-        if (typedValue.template is<mbgl::style::conversion::Error>()) {
-            Nan::ThrowTypeError(typedValue.template get<mbgl::style::conversion::Error>().message);
-            return false;
-        }
-
-        (typedLayer->*setter)(typedValue.template get<mbgl::style::PropertyValue<V>>());
-        return true;
-    };
-}
-
-inline bool setVisibility(mbgl::style::Layer& layer, const v8::Local<v8::Value>& value) {
-    if (value->IsNull() || value->IsUndefined()) {
-        layer.setVisibility(mbgl::style::VisibilityType::Visible);
-        return true;
-    }
-
-    if (!value->IsString()) {
-        Nan::ThrowTypeError("visibility value must be \"visible\" or \"none\"");
-        return false;
-    }
-
-    layer.setVisibility(std::string(*Nan::Utf8String(value)) == "none"
-        ? mbgl::style::VisibilityType::None
-        : mbgl::style::VisibilityType::Visible);
-
-   return true;
-}
-
-}
diff --git a/platform/node/src/node_style_properties.hpp b/platform/node/src/node_style_properties.hpp
deleted file mode 100644
index 0e3100207a..0000000000
--- a/platform/node/src/node_style_properties.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#include "node_style.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/raster_layer.hpp>
-#include <mbgl/style/layers/background_layer.hpp>
-
-namespace node_mbgl {
-
-inline PropertySetters makeLayoutPropertySetters() {
-    using namespace mbgl::style;
-    PropertySetters result;
-
-    result["visibility"] = &setVisibility;
-
-
-    result["line-cap"] = makePropertySetter(&LineLayer::setLineCap);
-    result["line-join"] = makePropertySetter(&LineLayer::setLineJoin);
-    result["line-miter-limit"] = makePropertySetter(&LineLayer::setLineMiterLimit);
-    result["line-round-limit"] = makePropertySetter(&LineLayer::setLineRoundLimit);
-
-    result["symbol-placement"] = makePropertySetter(&SymbolLayer::setSymbolPlacement);
-    result["symbol-spacing"] = makePropertySetter(&SymbolLayer::setSymbolSpacing);
-    result["symbol-avoid-edges"] = makePropertySetter(&SymbolLayer::setSymbolAvoidEdges);
-    result["icon-allow-overlap"] = makePropertySetter(&SymbolLayer::setIconAllowOverlap);
-    result["icon-ignore-placement"] = makePropertySetter(&SymbolLayer::setIconIgnorePlacement);
-    result["icon-optional"] = makePropertySetter(&SymbolLayer::setIconOptional);
-    result["icon-rotation-alignment"] = makePropertySetter(&SymbolLayer::setIconRotationAlignment);
-    result["icon-size"] = makePropertySetter(&SymbolLayer::setIconSize);
-    result["icon-text-fit"] = makePropertySetter(&SymbolLayer::setIconTextFit);
-    result["icon-text-fit-padding"] = makePropertySetter(&SymbolLayer::setIconTextFitPadding);
-    result["icon-image"] = makePropertySetter(&SymbolLayer::setIconImage);
-    result["icon-rotate"] = makePropertySetter(&SymbolLayer::setIconRotate);
-    result["icon-padding"] = makePropertySetter(&SymbolLayer::setIconPadding);
-    result["icon-keep-upright"] = makePropertySetter(&SymbolLayer::setIconKeepUpright);
-    result["icon-offset"] = makePropertySetter(&SymbolLayer::setIconOffset);
-    result["text-pitch-alignment"] = makePropertySetter(&SymbolLayer::setTextPitchAlignment);
-    result["text-rotation-alignment"] = makePropertySetter(&SymbolLayer::setTextRotationAlignment);
-    result["text-field"] = makePropertySetter(&SymbolLayer::setTextField);
-    result["text-font"] = makePropertySetter(&SymbolLayer::setTextFont);
-    result["text-size"] = makePropertySetter(&SymbolLayer::setTextSize);
-    result["text-max-width"] = makePropertySetter(&SymbolLayer::setTextMaxWidth);
-    result["text-line-height"] = makePropertySetter(&SymbolLayer::setTextLineHeight);
-    result["text-letter-spacing"] = makePropertySetter(&SymbolLayer::setTextLetterSpacing);
-    result["text-justify"] = makePropertySetter(&SymbolLayer::setTextJustify);
-    result["text-anchor"] = makePropertySetter(&SymbolLayer::setTextAnchor);
-    result["text-max-angle"] = makePropertySetter(&SymbolLayer::setTextMaxAngle);
-    result["text-rotate"] = makePropertySetter(&SymbolLayer::setTextRotate);
-    result["text-padding"] = makePropertySetter(&SymbolLayer::setTextPadding);
-    result["text-keep-upright"] = makePropertySetter(&SymbolLayer::setTextKeepUpright);
-    result["text-transform"] = makePropertySetter(&SymbolLayer::setTextTransform);
-    result["text-offset"] = makePropertySetter(&SymbolLayer::setTextOffset);
-    result["text-allow-overlap"] = makePropertySetter(&SymbolLayer::setTextAllowOverlap);
-    result["text-ignore-placement"] = makePropertySetter(&SymbolLayer::setTextIgnorePlacement);
-    result["text-optional"] = makePropertySetter(&SymbolLayer::setTextOptional);
-
-
-
-
-    return result;
-}
-
-inline PropertySetters makePaintPropertySetters() {
-    using namespace mbgl::style;
-    PropertySetters result;
-
-    result["fill-antialias"] = makePropertySetter(&FillLayer::setFillAntialias);
-    result["fill-opacity"] = makePropertySetter(&FillLayer::setFillOpacity);
-    result["fill-color"] = makePropertySetter(&FillLayer::setFillColor);
-    result["fill-outline-color"] = makePropertySetter(&FillLayer::setFillOutlineColor);
-    result["fill-translate"] = makePropertySetter(&FillLayer::setFillTranslate);
-    result["fill-translate-anchor"] = makePropertySetter(&FillLayer::setFillTranslateAnchor);
-    result["fill-pattern"] = makePropertySetter(&FillLayer::setFillPattern);
-
-    result["line-opacity"] = makePropertySetter(&LineLayer::setLineOpacity);
-    result["line-color"] = makePropertySetter(&LineLayer::setLineColor);
-    result["line-translate"] = makePropertySetter(&LineLayer::setLineTranslate);
-    result["line-translate-anchor"] = makePropertySetter(&LineLayer::setLineTranslateAnchor);
-    result["line-width"] = makePropertySetter(&LineLayer::setLineWidth);
-    result["line-gap-width"] = makePropertySetter(&LineLayer::setLineGapWidth);
-    result["line-offset"] = makePropertySetter(&LineLayer::setLineOffset);
-    result["line-blur"] = makePropertySetter(&LineLayer::setLineBlur);
-    result["line-dasharray"] = makePropertySetter(&LineLayer::setLineDasharray);
-    result["line-pattern"] = makePropertySetter(&LineLayer::setLinePattern);
-
-    result["icon-opacity"] = makePropertySetter(&SymbolLayer::setIconOpacity);
-    result["icon-color"] = makePropertySetter(&SymbolLayer::setIconColor);
-    result["icon-halo-color"] = makePropertySetter(&SymbolLayer::setIconHaloColor);
-    result["icon-halo-width"] = makePropertySetter(&SymbolLayer::setIconHaloWidth);
-    result["icon-halo-blur"] = makePropertySetter(&SymbolLayer::setIconHaloBlur);
-    result["icon-translate"] = makePropertySetter(&SymbolLayer::setIconTranslate);
-    result["icon-translate-anchor"] = makePropertySetter(&SymbolLayer::setIconTranslateAnchor);
-    result["text-opacity"] = makePropertySetter(&SymbolLayer::setTextOpacity);
-    result["text-color"] = makePropertySetter(&SymbolLayer::setTextColor);
-    result["text-halo-color"] = makePropertySetter(&SymbolLayer::setTextHaloColor);
-    result["text-halo-width"] = makePropertySetter(&SymbolLayer::setTextHaloWidth);
-    result["text-halo-blur"] = makePropertySetter(&SymbolLayer::setTextHaloBlur);
-    result["text-translate"] = makePropertySetter(&SymbolLayer::setTextTranslate);
-    result["text-translate-anchor"] = makePropertySetter(&SymbolLayer::setTextTranslateAnchor);
-
-    result["circle-radius"] = makePropertySetter(&CircleLayer::setCircleRadius);
-    result["circle-color"] = makePropertySetter(&CircleLayer::setCircleColor);
-    result["circle-blur"] = makePropertySetter(&CircleLayer::setCircleBlur);
-    result["circle-opacity"] = makePropertySetter(&CircleLayer::setCircleOpacity);
-    result["circle-translate"] = makePropertySetter(&CircleLayer::setCircleTranslate);
-    result["circle-translate-anchor"] = makePropertySetter(&CircleLayer::setCircleTranslateAnchor);
-
-    result["raster-opacity"] = makePropertySetter(&RasterLayer::setRasterOpacity);
-    result["raster-hue-rotate"] = makePropertySetter(&RasterLayer::setRasterHueRotate);
-    result["raster-brightness-min"] = makePropertySetter(&RasterLayer::setRasterBrightnessMin);
-    result["raster-brightness-max"] = makePropertySetter(&RasterLayer::setRasterBrightnessMax);
-    result["raster-saturation"] = makePropertySetter(&RasterLayer::setRasterSaturation);
-    result["raster-contrast"] = makePropertySetter(&RasterLayer::setRasterContrast);
-    result["raster-fade-duration"] = makePropertySetter(&RasterLayer::setRasterFadeDuration);
-
-    result["background-color"] = makePropertySetter(&BackgroundLayer::setBackgroundColor);
-    result["background-pattern"] = makePropertySetter(&BackgroundLayer::setBackgroundPattern);
-    result["background-opacity"] = makePropertySetter(&BackgroundLayer::setBackgroundOpacity);
-
-    return result;
-}
-
-inline bool setFilter(mbgl::style::Layer& layer, const mbgl::style::Filter& filter) {
-    using namespace mbgl::style;
-
-    if (layer.is<FillLayer>()) {
-        layer.as<FillLayer>()->setFilter(filter);
-        return true;
-    }
-    if (layer.is<LineLayer>()) {
-        layer.as<LineLayer>()->setFilter(filter);
-        return true;
-    }
-    if (layer.is<SymbolLayer>()) {
-        layer.as<SymbolLayer>()->setFilter(filter);
-        return true;
-    }
-    if (layer.is<CircleLayer>()) {
-        layer.as<CircleLayer>()->setFilter(filter);
-        return true;
-    }
-
-    Nan::ThrowTypeError("layer doesn't support filters");
-    return false;
-}
-
-}
diff --git a/platform/node/src/node_style_properties.hpp.ejs b/platform/node/src/node_style_properties.hpp.ejs
deleted file mode 100644
index bfd3f74ca5..0000000000
--- a/platform/node/src/node_style_properties.hpp.ejs
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "node_style.hpp"
-
-<% for (const layer of locals.layers) { -%>
-#include <mbgl/style/layers/<%- layer.type %>_layer.hpp>
-<% } -%>
-
-namespace node_mbgl {
-
-inline PropertySetters makeLayoutPropertySetters() {
-    using namespace mbgl::style;
-    PropertySetters result;
-
-    result["visibility"] = &setVisibility;
-
-<% for (const layer of locals.layers) { -%>
-<% for (const property of layer.layoutProperties) { -%>
-    result["<%- property.name %>"] = makePropertySetter(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
-<% } -%>
-
-<% } -%>
-    return result;
-}
-
-inline PropertySetters makePaintPropertySetters() {
-    using namespace mbgl::style;
-    PropertySetters result;
-
-<% for (const layer of locals.layers) { -%>
-<% for (const property of layer.paintProperties) { -%>
-    result["<%- property.name %>"] = makePropertySetter(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
-<% } -%>
-
-<% } -%>
-    return result;
-}
-
-inline bool setFilter(mbgl::style::Layer& layer, const mbgl::style::Filter& filter) {
-    using namespace mbgl::style;
-
-<% for (const layer of locals.layers) { -%>
-<% if (layer.type !== 'raster' && layer.type !== 'background' && layer.type !== 'custom') { -%>
-    if (layer.is<<%- camelize(layer.type) %>Layer>()) {
-        layer.as<<%- camelize(layer.type) %>Layer>()->setFilter(filter);
-        return true;
-    }
-<% } -%>
-<% } -%>
-
-    Nan::ThrowTypeError("layer doesn't support filters");
-    return false;
-}
-
-}
diff --git a/scripts/generate-style-code.js b/scripts/generate-style-code.js
index 7859c65a0e..642da1174b 100644
--- a/scripts/generate-style-code.js
+++ b/scripts/generate-style-code.js
@@ -111,5 +111,5 @@ for (const layer of layers) {
   fs.writeFileSync(`src/mbgl/style/layers/${layer.type}_layer_properties.cpp`, propertiesCpp(layer));
 }
 
-const nodeStyleCpp = ejs.compile(fs.readFileSync('platform/node/src/node_style_properties.hpp.ejs', 'utf8'), {strict: true});
-fs.writeFileSync('platform/node/src/node_style_properties.hpp', nodeStyleCpp({layers: layers}));
+const propertySettersHpp = ejs.compile(fs.readFileSync('include/mbgl/style/conversion/make_property_setters.hpp.ejs', 'utf8'), {strict: true});
+fs.writeFileSync('include/mbgl/style/conversion/make_property_setters.hpp', propertySettersHpp({layers: layers}));
diff --git a/src/mbgl/style/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp
index 33ad2e32ac..d2bf866e8e 100644
--- a/src/mbgl/style/layer_impl.hpp
+++ b/src/mbgl/style/layer_impl.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/filter.hpp>
 #include <mbgl/renderer/render_pass.hpp>
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/rapidjson.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 
 #include <memory>
@@ -46,8 +45,8 @@ public:
     // Create an identical copy of this layer.
     virtual std::unique_ptr<Layer> clone() const = 0;
 
-    virtual void parseLayout(const JSValue& value) = 0;
-    virtual void parsePaints(const JSValue& value) = 0;
+    // Create a layer, copying all properties except id, ref, and paint properties from this layer.
+    virtual std::unique_ptr<Layer> cloneRef(const std::string& id) const = 0;
 
     // If the layer has a ref, the ref. Otherwise, the id.
     const std::string& bucketName() const;
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index aeb4067503..42cd76d01f 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -23,6 +23,14 @@ std::unique_ptr<Layer> BackgroundLayer::Impl::clone() const {
     return std::make_unique<BackgroundLayer>(*this);
 }
 
+std::unique_ptr<Layer> BackgroundLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<BackgroundLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = BackgroundPaintProperties();
+    return std::move(result);
+}
+
 
 // Layout properties
 
@@ -33,24 +41,24 @@ PropertyValue<Color> BackgroundLayer::getBackgroundColor() const {
     return impl->paint.backgroundColor.get();
 }
 
-void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value) {
-    impl->paint.backgroundColor.set(value);
+void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.backgroundColor.set(value, klass);
 }
 
 PropertyValue<std::string> BackgroundLayer::getBackgroundPattern() const {
     return impl->paint.backgroundPattern.get();
 }
 
-void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value) {
-    impl->paint.backgroundPattern.set(value);
+void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+    impl->paint.backgroundPattern.set(value, klass);
 }
 
 PropertyValue<float> BackgroundLayer::getBackgroundOpacity() const {
     return impl->paint.backgroundOpacity.get();
 }
 
-void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value) {
-    impl->paint.backgroundOpacity.set(value);
+void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.backgroundOpacity.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/background_layer_impl.cpp b/src/mbgl/style/layers/background_layer_impl.cpp
index 0c09c5d158..ea389b828e 100644
--- a/src/mbgl/style/layers/background_layer_impl.cpp
+++ b/src/mbgl/style/layers/background_layer_impl.cpp
@@ -4,10 +4,6 @@
 namespace mbgl {
 namespace style {
 
-void BackgroundLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void BackgroundLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp
index 19e2a062a4..abbb740f42 100644
--- a/src/mbgl/style/layers/background_layer_impl.hpp
+++ b/src/mbgl/style/layers/background_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
 class BackgroundLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override {};
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/background_layer_properties.cpp b/src/mbgl/style/layers/background_layer_properties.cpp
index a20cedf12c..558093a255 100644
--- a/src/mbgl/style/layers/background_layer_properties.cpp
+++ b/src/mbgl/style/layers/background_layer_properties.cpp
@@ -5,12 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void BackgroundPaintProperties::parse(const JSValue& value) {
-    backgroundColor.parse("background-color", value);
-    backgroundPattern.parse("background-pattern", value);
-    backgroundOpacity.parse("background-opacity", value);
-}
-
 void BackgroundPaintProperties::cascade(const CascadeParameters& parameters) {
     backgroundColor.cascade(parameters);
     backgroundPattern.cascade(parameters);
diff --git a/src/mbgl/style/layers/background_layer_properties.hpp b/src/mbgl/style/layers/background_layer_properties.hpp
index 88a2ef1478..6c5a7c57ca 100644
--- a/src/mbgl/style/layers/background_layer_properties.hpp
+++ b/src/mbgl/style/layers/background_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class BackgroundPaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 8066d7fd3c..a47d723548 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> CircleLayer::Impl::clone() const {
     return std::make_unique<CircleLayer>(*this);
 }
 
+std::unique_ptr<Layer> CircleLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<CircleLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = CirclePaintProperties();
+    return std::move(result);
+}
+
 // Source
 
 const std::string& CircleLayer::getSourceID() const {
@@ -57,48 +65,48 @@ PropertyValue<float> CircleLayer::getCircleRadius() const {
     return impl->paint.circleRadius.get();
 }
 
-void CircleLayer::setCircleRadius(PropertyValue<float> value) {
-    impl->paint.circleRadius.set(value);
+void CircleLayer::setCircleRadius(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.circleRadius.set(value, klass);
 }
 
 PropertyValue<Color> CircleLayer::getCircleColor() const {
     return impl->paint.circleColor.get();
 }
 
-void CircleLayer::setCircleColor(PropertyValue<Color> value) {
-    impl->paint.circleColor.set(value);
+void CircleLayer::setCircleColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.circleColor.set(value, klass);
 }
 
 PropertyValue<float> CircleLayer::getCircleBlur() const {
     return impl->paint.circleBlur.get();
 }
 
-void CircleLayer::setCircleBlur(PropertyValue<float> value) {
-    impl->paint.circleBlur.set(value);
+void CircleLayer::setCircleBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.circleBlur.set(value, klass);
 }
 
 PropertyValue<float> CircleLayer::getCircleOpacity() const {
     return impl->paint.circleOpacity.get();
 }
 
-void CircleLayer::setCircleOpacity(PropertyValue<float> value) {
-    impl->paint.circleOpacity.set(value);
+void CircleLayer::setCircleOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.circleOpacity.set(value, klass);
 }
 
 PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate() const {
     return impl->paint.circleTranslate.get();
 }
 
-void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value) {
-    impl->paint.circleTranslate.set(value);
+void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+    impl->paint.circleTranslate.set(value, klass);
 }
 
 PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor() const {
     return impl->paint.circleTranslateAnchor.get();
 }
 
-void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
-    impl->paint.circleTranslateAnchor.set(value);
+void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+    impl->paint.circleTranslateAnchor.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp
index d64759e743..e08d9df146 100644
--- a/src/mbgl/style/layers/circle_layer_impl.cpp
+++ b/src/mbgl/style/layers/circle_layer_impl.cpp
@@ -8,10 +8,6 @@
 namespace mbgl {
 namespace style {
 
-void CircleLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void CircleLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp
index 463f3ca18d..555691b6b4 100644
--- a/src/mbgl/style/layers/circle_layer_impl.hpp
+++ b/src/mbgl/style/layers/circle_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
 class CircleLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override {};
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/circle_layer_properties.cpp b/src/mbgl/style/layers/circle_layer_properties.cpp
index b21df1e2d0..045c73ba63 100644
--- a/src/mbgl/style/layers/circle_layer_properties.cpp
+++ b/src/mbgl/style/layers/circle_layer_properties.cpp
@@ -5,15 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void CirclePaintProperties::parse(const JSValue& value) {
-    circleRadius.parse("circle-radius", value);
-    circleColor.parse("circle-color", value);
-    circleBlur.parse("circle-blur", value);
-    circleOpacity.parse("circle-opacity", value);
-    circleTranslate.parse("circle-translate", value);
-    circleTranslateAnchor.parse("circle-translate-anchor", value);
-}
-
 void CirclePaintProperties::cascade(const CascadeParameters& parameters) {
     circleRadius.cascade(parameters);
     circleColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/circle_layer_properties.hpp b/src/mbgl/style/layers/circle_layer_properties.hpp
index 87091e7b59..40d37dc392 100644
--- a/src/mbgl/style/layers/circle_layer_properties.hpp
+++ b/src/mbgl/style/layers/circle_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class CirclePaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/custom_layer_impl.cpp b/src/mbgl/style/layers/custom_layer_impl.cpp
index 214d4ce663..a0686e353c 100644
--- a/src/mbgl/style/layers/custom_layer_impl.cpp
+++ b/src/mbgl/style/layers/custom_layer_impl.cpp
@@ -33,6 +33,11 @@ std::unique_ptr<Layer> CustomLayer::Impl::clone() const {
     return std::make_unique<CustomLayer>(*this);
 }
 
+std::unique_ptr<Layer> CustomLayer::Impl::cloneRef(const std::string&) const {
+    assert(false);
+    return std::make_unique<CustomLayer>(*this);
+}
+
 void CustomLayer::Impl::initialize() {
     assert(initializeFn);
     initializeFn(context);
diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp
index 00e576b6a3..ffa892ddf8 100644
--- a/src/mbgl/style/layers/custom_layer_impl.hpp
+++ b/src/mbgl/style/layers/custom_layer_impl.hpp
@@ -25,9 +25,7 @@ public:
 
 private:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) final {}
-    void parsePaints(const JSValue&) final {}
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) final {}
     bool recalculate(const CalculationParameters&) final;
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 7d7d1a9e27..44894aff33 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> FillLayer::Impl::clone() const {
     return std::make_unique<FillLayer>(*this);
 }
 
+std::unique_ptr<Layer> FillLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<FillLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = FillPaintProperties();
+    return std::move(result);
+}
+
 // Source
 
 const std::string& FillLayer::getSourceID() const {
@@ -57,56 +65,56 @@ PropertyValue<bool> FillLayer::getFillAntialias() const {
     return impl->paint.fillAntialias.get();
 }
 
-void FillLayer::setFillAntialias(PropertyValue<bool> value) {
-    impl->paint.fillAntialias.set(value);
+void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) {
+    impl->paint.fillAntialias.set(value, klass);
 }
 
 PropertyValue<float> FillLayer::getFillOpacity() const {
     return impl->paint.fillOpacity.get();
 }
 
-void FillLayer::setFillOpacity(PropertyValue<float> value) {
-    impl->paint.fillOpacity.set(value);
+void FillLayer::setFillOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.fillOpacity.set(value, klass);
 }
 
 PropertyValue<Color> FillLayer::getFillColor() const {
     return impl->paint.fillColor.get();
 }
 
-void FillLayer::setFillColor(PropertyValue<Color> value) {
-    impl->paint.fillColor.set(value);
+void FillLayer::setFillColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.fillColor.set(value, klass);
 }
 
 PropertyValue<Color> FillLayer::getFillOutlineColor() const {
     return impl->paint.fillOutlineColor.get();
 }
 
-void FillLayer::setFillOutlineColor(PropertyValue<Color> value) {
-    impl->paint.fillOutlineColor.set(value);
+void FillLayer::setFillOutlineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.fillOutlineColor.set(value, klass);
 }
 
 PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate() const {
     return impl->paint.fillTranslate.get();
 }
 
-void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value) {
-    impl->paint.fillTranslate.set(value);
+void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+    impl->paint.fillTranslate.set(value, klass);
 }
 
 PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor() const {
     return impl->paint.fillTranslateAnchor.get();
 }
 
-void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
-    impl->paint.fillTranslateAnchor.set(value);
+void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+    impl->paint.fillTranslateAnchor.set(value, klass);
 }
 
 PropertyValue<std::string> FillLayer::getFillPattern() const {
     return impl->paint.fillPattern.get();
 }
 
-void FillLayer::setFillPattern(PropertyValue<std::string> value) {
-    impl->paint.fillPattern.set(value);
+void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+    impl->paint.fillPattern.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp
index 3d847127c9..2992312514 100644
--- a/src/mbgl/style/layers/fill_layer_impl.cpp
+++ b/src/mbgl/style/layers/fill_layer_impl.cpp
@@ -8,10 +8,6 @@
 namespace mbgl {
 namespace style {
 
-void FillLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void FillLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp
index a37dd76ace..fc6578ecd1 100644
--- a/src/mbgl/style/layers/fill_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
 class FillLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override {};
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/fill_layer_properties.cpp b/src/mbgl/style/layers/fill_layer_properties.cpp
index a4714689f9..9a55cbc145 100644
--- a/src/mbgl/style/layers/fill_layer_properties.cpp
+++ b/src/mbgl/style/layers/fill_layer_properties.cpp
@@ -5,16 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void FillPaintProperties::parse(const JSValue& value) {
-    fillAntialias.parse("fill-antialias", value);
-    fillOpacity.parse("fill-opacity", value);
-    fillColor.parse("fill-color", value);
-    fillOutlineColor.parse("fill-outline-color", value);
-    fillTranslate.parse("fill-translate", value);
-    fillTranslateAnchor.parse("fill-translate-anchor", value);
-    fillPattern.parse("fill-pattern", value);
-}
-
 void FillPaintProperties::cascade(const CascadeParameters& parameters) {
     fillAntialias.cascade(parameters);
     fillOpacity.cascade(parameters);
diff --git a/src/mbgl/style/layers/fill_layer_properties.hpp b/src/mbgl/style/layers/fill_layer_properties.hpp
index fb60b90258..82981a9b64 100644
--- a/src/mbgl/style/layers/fill_layer_properties.hpp
+++ b/src/mbgl/style/layers/fill_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class FillPaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 4f78d6b55e..017691c8ec 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -37,6 +37,14 @@ std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::clone() const {
     return std::make_unique<<%- camelize(type) %>Layer>(*this);
 }
 
+std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<<%- camelize(type) %>Layer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = <%- camelize(type) %>PaintProperties();
+    return std::move(result);
+}
+
 <% if (type !== 'background') { -%>
 // Source
 
@@ -83,8 +91,8 @@ PropertyValue<<%- propertyType(property) %>> <%- camelize(type) %>Layer::get<%-
     return impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.get();
 }
 
-void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>> value) {
-    impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.set(value);
+void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>> value, const optional<std::string>& klass) {
+    impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.set(value, klass);
 }
 <% } -%>
 
diff --git a/src/mbgl/style/layers/layer_properties.cpp.ejs b/src/mbgl/style/layers/layer_properties.cpp.ejs
index 8fef8d29c4..b781a4a9d9 100644
--- a/src/mbgl/style/layers/layer_properties.cpp.ejs
+++ b/src/mbgl/style/layers/layer_properties.cpp.ejs
@@ -11,12 +11,6 @@ namespace mbgl {
 namespace style {
 
 <% if (layoutProperties.length) { -%>
-void <%- camelize(type) %>LayoutProperties::parse(const JSValue& value) {
-<% for (const property of layoutProperties) { -%>
-    <%- camelizeWithLeadingLowercase(property.name) %>.parse(<%- JSON.stringify(property.name) %>, value);
-<% } -%>
-}
-
 void <%- camelize(type) %>LayoutProperties::recalculate(const CalculationParameters& parameters) {
 <% for (const property of layoutProperties) { -%>
     <%- camelizeWithLeadingLowercase(property.name) %>.calculate(parameters);
@@ -24,12 +18,6 @@ void <%- camelize(type) %>LayoutProperties::recalculate(const CalculationParamet
 }
 
 <% } -%>
-void <%- camelize(type) %>PaintProperties::parse(const JSValue& value) {
-<% for (const property of paintProperties) { -%>
-    <%- camelizeWithLeadingLowercase(property.name) %>.parse(<%- JSON.stringify(property.name) %>, value);
-<% } -%>
-}
-
 void <%- camelize(type) %>PaintProperties::cascade(const CascadeParameters& parameters) {
 <% for (const property of paintProperties) { -%>
     <%- camelizeWithLeadingLowercase(property.name) %>.cascade(parameters);
diff --git a/src/mbgl/style/layers/layer_properties.hpp.ejs b/src/mbgl/style/layers/layer_properties.hpp.ejs
index 60f40efa8e..a485621ac6 100644
--- a/src/mbgl/style/layers/layer_properties.hpp.ejs
+++ b/src/mbgl/style/layers/layer_properties.hpp.ejs
@@ -10,7 +10,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -21,7 +20,6 @@ class CalculationParameters;
 <% if (layoutProperties.length) { -%>
 class <%- camelize(type) %>LayoutProperties {
 public:
-    void parse(const JSValue&);
     void recalculate(const CalculationParameters&);
 
 <% for (const property of layoutProperties) { -%>
@@ -32,7 +30,6 @@ public:
 <% } -%>
 class <%- camelize(type) %>PaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index e720d1fcfb..3ad72cda16 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> LineLayer::Impl::clone() const {
     return std::make_unique<LineLayer>(*this);
 }
 
+std::unique_ptr<Layer> LineLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<LineLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = LinePaintProperties();
+    return std::move(result);
+}
+
 // Source
 
 const std::string& LineLayer::getSourceID() const {
@@ -85,80 +93,80 @@ PropertyValue<float> LineLayer::getLineOpacity() const {
     return impl->paint.lineOpacity.get();
 }
 
-void LineLayer::setLineOpacity(PropertyValue<float> value) {
-    impl->paint.lineOpacity.set(value);
+void LineLayer::setLineOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.lineOpacity.set(value, klass);
 }
 
 PropertyValue<Color> LineLayer::getLineColor() const {
     return impl->paint.lineColor.get();
 }
 
-void LineLayer::setLineColor(PropertyValue<Color> value) {
-    impl->paint.lineColor.set(value);
+void LineLayer::setLineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.lineColor.set(value, klass);
 }
 
 PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate() const {
     return impl->paint.lineTranslate.get();
 }
 
-void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value) {
-    impl->paint.lineTranslate.set(value);
+void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+    impl->paint.lineTranslate.set(value, klass);
 }
 
 PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor() const {
     return impl->paint.lineTranslateAnchor.get();
 }
 
-void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
-    impl->paint.lineTranslateAnchor.set(value);
+void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+    impl->paint.lineTranslateAnchor.set(value, klass);
 }
 
 PropertyValue<float> LineLayer::getLineWidth() const {
     return impl->paint.lineWidth.get();
 }
 
-void LineLayer::setLineWidth(PropertyValue<float> value) {
-    impl->paint.lineWidth.set(value);
+void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.lineWidth.set(value, klass);
 }
 
 PropertyValue<float> LineLayer::getLineGapWidth() const {
     return impl->paint.lineGapWidth.get();
 }
 
-void LineLayer::setLineGapWidth(PropertyValue<float> value) {
-    impl->paint.lineGapWidth.set(value);
+void LineLayer::setLineGapWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.lineGapWidth.set(value, klass);
 }
 
 PropertyValue<float> LineLayer::getLineOffset() const {
     return impl->paint.lineOffset.get();
 }
 
-void LineLayer::setLineOffset(PropertyValue<float> value) {
-    impl->paint.lineOffset.set(value);
+void LineLayer::setLineOffset(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.lineOffset.set(value, klass);
 }
 
 PropertyValue<float> LineLayer::getLineBlur() const {
     return impl->paint.lineBlur.get();
 }
 
-void LineLayer::setLineBlur(PropertyValue<float> value) {
-    impl->paint.lineBlur.set(value);
+void LineLayer::setLineBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.lineBlur.set(value, klass);
 }
 
 PropertyValue<std::vector<float>> LineLayer::getLineDasharray() const {
     return impl->paint.lineDasharray.get();
 }
 
-void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value) {
-    impl->paint.lineDasharray.set(value);
+void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) {
+    impl->paint.lineDasharray.set(value, klass);
 }
 
 PropertyValue<std::string> LineLayer::getLinePattern() const {
     return impl->paint.linePattern.get();
 }
 
-void LineLayer::setLinePattern(PropertyValue<std::string> value) {
-    impl->paint.linePattern.set(value);
+void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+    impl->paint.linePattern.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp
index 589b129ee6..3cdd90b7fd 100644
--- a/src/mbgl/style/layers/line_layer_impl.cpp
+++ b/src/mbgl/style/layers/line_layer_impl.cpp
@@ -8,14 +8,6 @@
 namespace mbgl {
 namespace style {
 
-void LineLayer::Impl::parseLayout(const JSValue& value) {
-    layout.parse(value);
-}
-
-void LineLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void LineLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp
index 3356dc2ceb..e130bc01bc 100644
--- a/src/mbgl/style/layers/line_layer_impl.hpp
+++ b/src/mbgl/style/layers/line_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
 class LineLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override;
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/line_layer_properties.cpp b/src/mbgl/style/layers/line_layer_properties.cpp
index 7c74f6de04..2d6092745e 100644
--- a/src/mbgl/style/layers/line_layer_properties.cpp
+++ b/src/mbgl/style/layers/line_layer_properties.cpp
@@ -5,13 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void LineLayoutProperties::parse(const JSValue& value) {
-    lineCap.parse("line-cap", value);
-    lineJoin.parse("line-join", value);
-    lineMiterLimit.parse("line-miter-limit", value);
-    lineRoundLimit.parse("line-round-limit", value);
-}
-
 void LineLayoutProperties::recalculate(const CalculationParameters& parameters) {
     lineCap.calculate(parameters);
     lineJoin.calculate(parameters);
@@ -19,19 +12,6 @@ void LineLayoutProperties::recalculate(const CalculationParameters& parameters)
     lineRoundLimit.calculate(parameters);
 }
 
-void LinePaintProperties::parse(const JSValue& value) {
-    lineOpacity.parse("line-opacity", value);
-    lineColor.parse("line-color", value);
-    lineTranslate.parse("line-translate", value);
-    lineTranslateAnchor.parse("line-translate-anchor", value);
-    lineWidth.parse("line-width", value);
-    lineGapWidth.parse("line-gap-width", value);
-    lineOffset.parse("line-offset", value);
-    lineBlur.parse("line-blur", value);
-    lineDasharray.parse("line-dasharray", value);
-    linePattern.parse("line-pattern", value);
-}
-
 void LinePaintProperties::cascade(const CascadeParameters& parameters) {
     lineOpacity.cascade(parameters);
     lineColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/line_layer_properties.hpp b/src/mbgl/style/layers/line_layer_properties.hpp
index 0bc08f1988..e7dbddf442 100644
--- a/src/mbgl/style/layers/line_layer_properties.hpp
+++ b/src/mbgl/style/layers/line_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class LineLayoutProperties {
 public:
-    void parse(const JSValue&);
     void recalculate(const CalculationParameters&);
 
     LayoutProperty<LineCapType> lineCap { LineCapType::Butt };
@@ -26,7 +24,6 @@ public:
 
 class LinePaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index cdba19ac4e..d4e121babe 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> RasterLayer::Impl::clone() const {
     return std::make_unique<RasterLayer>(*this);
 }
 
+std::unique_ptr<Layer> RasterLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<RasterLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = RasterPaintProperties();
+    return std::move(result);
+}
+
 // Source
 
 const std::string& RasterLayer::getSourceID() const {
@@ -40,56 +48,56 @@ PropertyValue<float> RasterLayer::getRasterOpacity() const {
     return impl->paint.rasterOpacity.get();
 }
 
-void RasterLayer::setRasterOpacity(PropertyValue<float> value) {
-    impl->paint.rasterOpacity.set(value);
+void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterOpacity.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterHueRotate() const {
     return impl->paint.rasterHueRotate.get();
 }
 
-void RasterLayer::setRasterHueRotate(PropertyValue<float> value) {
-    impl->paint.rasterHueRotate.set(value);
+void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterHueRotate.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterBrightnessMin() const {
     return impl->paint.rasterBrightnessMin.get();
 }
 
-void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value) {
-    impl->paint.rasterBrightnessMin.set(value);
+void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterBrightnessMin.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterBrightnessMax() const {
     return impl->paint.rasterBrightnessMax.get();
 }
 
-void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value) {
-    impl->paint.rasterBrightnessMax.set(value);
+void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterBrightnessMax.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterSaturation() const {
     return impl->paint.rasterSaturation.get();
 }
 
-void RasterLayer::setRasterSaturation(PropertyValue<float> value) {
-    impl->paint.rasterSaturation.set(value);
+void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterSaturation.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterContrast() const {
     return impl->paint.rasterContrast.get();
 }
 
-void RasterLayer::setRasterContrast(PropertyValue<float> value) {
-    impl->paint.rasterContrast.set(value);
+void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterContrast.set(value, klass);
 }
 
 PropertyValue<float> RasterLayer::getRasterFadeDuration() const {
     return impl->paint.rasterFadeDuration.get();
 }
 
-void RasterLayer::setRasterFadeDuration(PropertyValue<float> value) {
-    impl->paint.rasterFadeDuration.set(value);
+void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.rasterFadeDuration.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp
index 4854ec041d..879bfa4559 100644
--- a/src/mbgl/style/layers/raster_layer_impl.cpp
+++ b/src/mbgl/style/layers/raster_layer_impl.cpp
@@ -4,10 +4,6 @@
 namespace mbgl {
 namespace style {
 
-void RasterLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void RasterLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp
index 6812b469a6..a5b396e2ed 100644
--- a/src/mbgl/style/layers/raster_layer_impl.hpp
+++ b/src/mbgl/style/layers/raster_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
 class RasterLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override {};
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/raster_layer_properties.cpp b/src/mbgl/style/layers/raster_layer_properties.cpp
index 0e6afc5e9c..68d9d1d35d 100644
--- a/src/mbgl/style/layers/raster_layer_properties.cpp
+++ b/src/mbgl/style/layers/raster_layer_properties.cpp
@@ -5,16 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void RasterPaintProperties::parse(const JSValue& value) {
-    rasterOpacity.parse("raster-opacity", value);
-    rasterHueRotate.parse("raster-hue-rotate", value);
-    rasterBrightnessMin.parse("raster-brightness-min", value);
-    rasterBrightnessMax.parse("raster-brightness-max", value);
-    rasterSaturation.parse("raster-saturation", value);
-    rasterContrast.parse("raster-contrast", value);
-    rasterFadeDuration.parse("raster-fade-duration", value);
-}
-
 void RasterPaintProperties::cascade(const CascadeParameters& parameters) {
     rasterOpacity.cascade(parameters);
     rasterHueRotate.cascade(parameters);
diff --git a/src/mbgl/style/layers/raster_layer_properties.hpp b/src/mbgl/style/layers/raster_layer_properties.hpp
index 1581ca6687..ddfb833e12 100644
--- a/src/mbgl/style/layers/raster_layer_properties.hpp
+++ b/src/mbgl/style/layers/raster_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class RasterPaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 905caa0310..c26123f0ec 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> SymbolLayer::Impl::clone() const {
     return std::make_unique<SymbolLayer>(*this);
 }
 
+std::unique_ptr<Layer> SymbolLayer::Impl::cloneRef(const std::string& id_) const {
+    auto result = std::make_unique<SymbolLayer>(*this);
+    result->impl->id = id_;
+    result->impl->ref = this->id;
+    result->impl->paint = SymbolPaintProperties();
+    return std::move(result);
+}
+
 // Source
 
 const std::string& SymbolLayer::getSourceID() const {
@@ -295,112 +303,112 @@ PropertyValue<float> SymbolLayer::getIconOpacity() const {
     return impl->paint.iconOpacity.get();
 }
 
-void SymbolLayer::setIconOpacity(PropertyValue<float> value) {
-    impl->paint.iconOpacity.set(value);
+void SymbolLayer::setIconOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.iconOpacity.set(value, klass);
 }
 
 PropertyValue<Color> SymbolLayer::getIconColor() const {
     return impl->paint.iconColor.get();
 }
 
-void SymbolLayer::setIconColor(PropertyValue<Color> value) {
-    impl->paint.iconColor.set(value);
+void SymbolLayer::setIconColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.iconColor.set(value, klass);
 }
 
 PropertyValue<Color> SymbolLayer::getIconHaloColor() const {
     return impl->paint.iconHaloColor.get();
 }
 
-void SymbolLayer::setIconHaloColor(PropertyValue<Color> value) {
-    impl->paint.iconHaloColor.set(value);
+void SymbolLayer::setIconHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.iconHaloColor.set(value, klass);
 }
 
 PropertyValue<float> SymbolLayer::getIconHaloWidth() const {
     return impl->paint.iconHaloWidth.get();
 }
 
-void SymbolLayer::setIconHaloWidth(PropertyValue<float> value) {
-    impl->paint.iconHaloWidth.set(value);
+void SymbolLayer::setIconHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.iconHaloWidth.set(value, klass);
 }
 
 PropertyValue<float> SymbolLayer::getIconHaloBlur() const {
     return impl->paint.iconHaloBlur.get();
 }
 
-void SymbolLayer::setIconHaloBlur(PropertyValue<float> value) {
-    impl->paint.iconHaloBlur.set(value);
+void SymbolLayer::setIconHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.iconHaloBlur.set(value, klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate() const {
     return impl->paint.iconTranslate.get();
 }
 
-void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value) {
-    impl->paint.iconTranslate.set(value);
+void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+    impl->paint.iconTranslate.set(value, klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor() const {
     return impl->paint.iconTranslateAnchor.get();
 }
 
-void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
-    impl->paint.iconTranslateAnchor.set(value);
+void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+    impl->paint.iconTranslateAnchor.set(value, klass);
 }
 
 PropertyValue<float> SymbolLayer::getTextOpacity() const {
     return impl->paint.textOpacity.get();
 }
 
-void SymbolLayer::setTextOpacity(PropertyValue<float> value) {
-    impl->paint.textOpacity.set(value);
+void SymbolLayer::setTextOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.textOpacity.set(value, klass);
 }
 
 PropertyValue<Color> SymbolLayer::getTextColor() const {
     return impl->paint.textColor.get();
 }
 
-void SymbolLayer::setTextColor(PropertyValue<Color> value) {
-    impl->paint.textColor.set(value);
+void SymbolLayer::setTextColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.textColor.set(value, klass);
 }
 
 PropertyValue<Color> SymbolLayer::getTextHaloColor() const {
     return impl->paint.textHaloColor.get();
 }
 
-void SymbolLayer::setTextHaloColor(PropertyValue<Color> value) {
-    impl->paint.textHaloColor.set(value);
+void SymbolLayer::setTextHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+    impl->paint.textHaloColor.set(value, klass);
 }
 
 PropertyValue<float> SymbolLayer::getTextHaloWidth() const {
     return impl->paint.textHaloWidth.get();
 }
 
-void SymbolLayer::setTextHaloWidth(PropertyValue<float> value) {
-    impl->paint.textHaloWidth.set(value);
+void SymbolLayer::setTextHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.textHaloWidth.set(value, klass);
 }
 
 PropertyValue<float> SymbolLayer::getTextHaloBlur() const {
     return impl->paint.textHaloBlur.get();
 }
 
-void SymbolLayer::setTextHaloBlur(PropertyValue<float> value) {
-    impl->paint.textHaloBlur.set(value);
+void SymbolLayer::setTextHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+    impl->paint.textHaloBlur.set(value, klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate() const {
     return impl->paint.textTranslate.get();
 }
 
-void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value) {
-    impl->paint.textTranslate.set(value);
+void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+    impl->paint.textTranslate.set(value, klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor() const {
     return impl->paint.textTranslateAnchor.get();
 }
 
-void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
-    impl->paint.textTranslateAnchor.set(value);
+void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+    impl->paint.textTranslateAnchor.set(value, klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp
index eeceb52078..0243b1dfa5 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.cpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.cpp
@@ -5,14 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void SymbolLayer::Impl::parseLayout(const JSValue& value) {
-    layout.parse(value);
-}
-
-void SymbolLayer::Impl::parsePaints(const JSValue& layer) {
-    paint.parse(layer);
-}
-
 void SymbolLayer::Impl::cascade(const CascadeParameters& parameters) {
     paint.cascade(parameters);
 }
diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp
index 9727cc6480..7765d6790e 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.hpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.hpp
@@ -13,9 +13,7 @@ namespace style {
 class SymbolLayer::Impl : public Layer::Impl {
 public:
     std::unique_ptr<Layer> clone() const override;
-
-    void parseLayout(const JSValue&) override;
-    void parsePaints(const JSValue&) override;
+    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
 
     void cascade(const CascadeParameters&) override;
     bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/symbol_layer_properties.cpp b/src/mbgl/style/layers/symbol_layer_properties.cpp
index d77d10700c..59a73d3d59 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.cpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.cpp
@@ -5,43 +5,6 @@
 namespace mbgl {
 namespace style {
 
-void SymbolLayoutProperties::parse(const JSValue& value) {
-    symbolPlacement.parse("symbol-placement", value);
-    symbolSpacing.parse("symbol-spacing", value);
-    symbolAvoidEdges.parse("symbol-avoid-edges", value);
-    iconAllowOverlap.parse("icon-allow-overlap", value);
-    iconIgnorePlacement.parse("icon-ignore-placement", value);
-    iconOptional.parse("icon-optional", value);
-    iconRotationAlignment.parse("icon-rotation-alignment", value);
-    iconSize.parse("icon-size", value);
-    iconTextFit.parse("icon-text-fit", value);
-    iconTextFitPadding.parse("icon-text-fit-padding", value);
-    iconImage.parse("icon-image", value);
-    iconRotate.parse("icon-rotate", value);
-    iconPadding.parse("icon-padding", value);
-    iconKeepUpright.parse("icon-keep-upright", value);
-    iconOffset.parse("icon-offset", value);
-    textPitchAlignment.parse("text-pitch-alignment", value);
-    textRotationAlignment.parse("text-rotation-alignment", value);
-    textField.parse("text-field", value);
-    textFont.parse("text-font", value);
-    textSize.parse("text-size", value);
-    textMaxWidth.parse("text-max-width", value);
-    textLineHeight.parse("text-line-height", value);
-    textLetterSpacing.parse("text-letter-spacing", value);
-    textJustify.parse("text-justify", value);
-    textAnchor.parse("text-anchor", value);
-    textMaxAngle.parse("text-max-angle", value);
-    textRotate.parse("text-rotate", value);
-    textPadding.parse("text-padding", value);
-    textKeepUpright.parse("text-keep-upright", value);
-    textTransform.parse("text-transform", value);
-    textOffset.parse("text-offset", value);
-    textAllowOverlap.parse("text-allow-overlap", value);
-    textIgnorePlacement.parse("text-ignore-placement", value);
-    textOptional.parse("text-optional", value);
-}
-
 void SymbolLayoutProperties::recalculate(const CalculationParameters& parameters) {
     symbolPlacement.calculate(parameters);
     symbolSpacing.calculate(parameters);
@@ -79,23 +42,6 @@ void SymbolLayoutProperties::recalculate(const CalculationParameters& parameters
     textOptional.calculate(parameters);
 }
 
-void SymbolPaintProperties::parse(const JSValue& value) {
-    iconOpacity.parse("icon-opacity", value);
-    iconColor.parse("icon-color", value);
-    iconHaloColor.parse("icon-halo-color", value);
-    iconHaloWidth.parse("icon-halo-width", value);
-    iconHaloBlur.parse("icon-halo-blur", value);
-    iconTranslate.parse("icon-translate", value);
-    iconTranslateAnchor.parse("icon-translate-anchor", value);
-    textOpacity.parse("text-opacity", value);
-    textColor.parse("text-color", value);
-    textHaloColor.parse("text-halo-color", value);
-    textHaloWidth.parse("text-halo-width", value);
-    textHaloBlur.parse("text-halo-blur", value);
-    textTranslate.parse("text-translate", value);
-    textTranslateAnchor.parse("text-translate-anchor", value);
-}
-
 void SymbolPaintProperties::cascade(const CascadeParameters& parameters) {
     iconOpacity.cascade(parameters);
     iconColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp
index 378562d605..a269969cb8 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.hpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/layout_property.hpp>
 #include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 namespace mbgl {
 namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
 
 class SymbolLayoutProperties {
 public:
-    void parse(const JSValue&);
     void recalculate(const CalculationParameters&);
 
     LayoutProperty<SymbolPlacementType> symbolPlacement { SymbolPlacementType::Point };
@@ -56,7 +54,6 @@ public:
 
 class SymbolPaintProperties {
 public:
-    void parse(const JSValue&);
     void cascade(const CascadeParameters&);
     bool recalculate(const CalculationParameters&);
 
diff --git a/src/mbgl/style/layout_property.hpp b/src/mbgl/style/layout_property.hpp
index f5045b47fc..db1a1ebf28 100644
--- a/src/mbgl/style/layout_property.hpp
+++ b/src/mbgl/style/layout_property.hpp
@@ -3,7 +3,6 @@
 #include <mbgl/style/property_value.hpp>
 #include <mbgl/style/property_parsing.hpp>
 #include <mbgl/style/property_evaluator.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 #include <utility>
 
@@ -25,12 +24,6 @@ public:
         currentValue = value_;
     }
 
-    void parse(const char * name, const JSValue& layout) {
-        if (layout.HasMember(name)) {
-            currentValue = parseProperty<T>(name, layout[name]);
-        }
-    }
-
     void calculate(const CalculationParameters& parameters) {
         if (currentValue) {
             PropertyEvaluator<T> evaluator(parameters, defaultValue);
diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp
index 7bb2e68b80..b982fe76e2 100644
--- a/src/mbgl/style/paint_property.hpp
+++ b/src/mbgl/style/paint_property.hpp
@@ -8,7 +8,6 @@
 #include <mbgl/style/calculation_parameters.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/interpolate.hpp>
-#include <mbgl/util/std.hpp>
 #include <mbgl/util/rapidjson.hpp>
 
 #include <map>
@@ -28,47 +27,28 @@ public:
     }
 
     PaintProperty(const PaintProperty& other)
-        : values(other.values),
+        : defaultValue(other.defaultValue),
+          values(other.values),
           transitions(other.transitions) {
     }
 
+    PaintProperty& operator=(const PaintProperty& other) {
+        defaultValue = other.defaultValue;
+        values = other.values;
+        transitions = other.transitions;
+        return *this;
+    }
+
     const PropertyValue<T>& get() const {
         return values.at(ClassID::Default);
     }
 
-    void set(const PropertyValue<T>& value_) {
-        values[ClassID::Default] = value_;
+    void set(const PropertyValue<T>& value_, const optional<std::string>& klass) {
+        values[klass ? ClassDictionary::Get().lookup(*klass) : ClassID::Default] = value_;
     }
 
-    void parse(const char* name, const JSValue& layer) {
-        mbgl::util::erase_if(values, [] (const auto& p) { return p.first != ClassID::Fallback; });
-
-        std::string transitionName = { name };
-        transitionName += "-transition";
-
-        for (auto it = layer.MemberBegin(); it != layer.MemberEnd(); ++it) {
-            const std::string paintName { it->name.GetString(), it->name.GetStringLength() };
-            if (paintName.compare(0, 5, "paint") != 0)
-                continue;
-
-            bool isClass = paintName.compare(0, 6, "paint.") == 0;
-            if (isClass && paintName.length() <= 6)
-                continue;
-
-            ClassID classID = isClass ? ClassDictionary::Get().lookup(paintName.substr(6)) : ClassID::Default;
-
-            if (it->value.HasMember(name)) {
-                if (auto v = parseProperty<T>(name, it->value[name])) {
-                    values.emplace(classID, v);
-                }
-            }
-
-            if (it->value.HasMember(transitionName.c_str())) {
-                if (auto v = parseTransitionOptions(name, it->value[transitionName.c_str()])) {
-                    transitions.emplace(classID, *v);
-                }
-            }
-        }
+    void setTransition(const TransitionOptions& transition, const optional<std::string>& klass) {
+        transitions[klass ? ClassDictionary::Get().lookup(*klass) : ClassID::Default] = transition;
     }
 
     void cascade(const CascadeParameters& params) {
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index a0f4dd24c9..ac263dbc57 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -11,7 +11,7 @@
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/rapidjson_conversion.hpp>
 #include <mbgl/style/conversion.hpp>
-#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/layer.hpp>
 
 #include <mbgl/platform/log.hpp>
 
@@ -219,120 +219,16 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
             return;
         }
 
-        layer = reference->baseImpl->copy(id, ref, reference->baseImpl->source);
-        layer->baseImpl->parsePaints(value);
+        layer = reference->baseImpl->cloneRef(id);
+        conversion::setPaintProperties(*layer, value);
     } else {
-        // Otherwise, parse the source/source-layer/filter/render keys to form the bucket.
-        if (!value.HasMember("type")) {
-            Log::Warning(Event::ParseStyle, "layer '%s' is missing a type", id.c_str());
+        conversion::Result<std::unique_ptr<Layer>> converted = conversion::convert<std::unique_ptr<Layer>>(value);
+        if (!converted) {
+            Log::Warning(Event::ParseStyle, converted.error().message);
             return;
         }
-
-        const JSValue& typeVal = value["type"];
-        if (!typeVal.IsString()) {
-            Log::Warning(Event::ParseStyle, "layer '%s' has an invalid type", id.c_str());
-            return;
-        }
-
-        std::string type { typeVal.GetString(), typeVal.GetStringLength() };
-        std::string source;
-
-        if (value.HasMember("source")) {
-            const JSValue& value_source = value["source"];
-            if (value_source.IsString()) {
-                source = { value_source.GetString(), value_source.GetStringLength() };
-                auto source_it = sourcesMap.find(source);
-                if (source_it == sourcesMap.end()) {
-                    Log::Warning(Event::ParseStyle, "can't find source '%s' required for layer '%s'", source.c_str(), id.c_str());
-                }
-            } else {
-                Log::Warning(Event::ParseStyle, "source of layer '%s' must be a string", id.c_str());
-            }
-        }
-
-        if (type == "fill") {
-            layer = std::make_unique<FillLayer>(id, source);
-        } else if (type == "line") {
-            layer = std::make_unique<LineLayer>(id, source);
-        } else if (type == "circle") {
-            layer = std::make_unique<CircleLayer>(id, source);
-        } else if (type == "symbol") {
-            layer = std::make_unique<SymbolLayer>(id, source);
-        } else if (type == "raster") {
-            layer = std::make_unique<RasterLayer>(id, source);
-        } else if (type == "background") {
-            layer = std::make_unique<BackgroundLayer>(id);
-        } else {
-            Log::Warning(Event::ParseStyle, "unknown type '%s' for layer '%s'", type.c_str(), id.c_str());
-            return;
-        }
-
-        Layer::Impl* impl = layer->baseImpl.get();
-
-        if (value.HasMember("source-layer")) {
-            const JSValue& value_source_layer = value["source-layer"];
-            if (value_source_layer.IsString()) {
-                impl->sourceLayer = { value_source_layer.GetString(), value_source_layer.GetStringLength() };
-            } else {
-                Log::Warning(Event::ParseStyle, "source-layer of layer '%s' must be a string", impl->id.c_str());
-            }
-        }
-
-        if (value.HasMember("filter")) {
-            conversion::Result<Filter> filter = conversion::convert<Filter>(value["filter"]);
-            if (filter) {
-                impl->filter = *filter;
-            } else {
-                Log::Warning(Event::ParseStyle, filter.error().message);
-            }
-        }
-
-        if (value.HasMember("minzoom")) {
-            const JSValue& min_zoom = value["minzoom"];
-            if (min_zoom.IsNumber()) {
-                impl->minZoom = min_zoom.GetDouble();
-            } else {
-                Log::Warning(Event::ParseStyle, "minzoom of layer %s must be numeric", impl->id.c_str());
-            }
-        }
-
-        if (value.HasMember("maxzoom")) {
-            const JSValue& max_zoom = value["maxzoom"];
-            if (max_zoom.IsNumber()) {
-                impl->maxZoom = max_zoom.GetDouble();
-            } else {
-                Log::Warning(Event::ParseStyle, "maxzoom of layer %s must be numeric", impl->id.c_str());
-            }
-        }
-
-        if (value.HasMember("layout")) {
-            parseVisibility(*layer, value["layout"]);
-            impl->parseLayout(value["layout"]);
-        }
-
-        impl->parsePaints(value);
-    }
-}
-
-void Parser::parseVisibility(Layer& layer, const JSValue& value) {
-    Layer::Impl& impl = *layer.baseImpl;
-
-    if (!value.HasMember("visibility")) {
-        return;
-    }
-
-    if (!value["visibility"].IsString()) {
-        Log::Warning(Event::ParseStyle, "value of 'visibility' must be a string");
-        return;
+        layer = std::move(*converted);
     }
-
-    const auto enumValue = Enum<VisibilityType>::toEnum({ value["visibility"].GetString(), value["visibility"].GetStringLength() });
-    if (!enumValue) {
-        Log::Warning(Event::ParseStyle, "value of 'visibility' must be a valid enumeration value");
-        return;
-    }
-
-    impl.visibility = *enumValue;
 }
 
 std::vector<FontStack> Parser::fontStacks() const {
diff --git a/src/mbgl/style/parser.hpp b/src/mbgl/style/parser.hpp
index 30da0dd2b0..faf80cee93 100644
--- a/src/mbgl/style/parser.hpp
+++ b/src/mbgl/style/parser.hpp
@@ -34,7 +34,6 @@ private:
     void parseSources(const JSValue&);
     void parseLayers(const JSValue&);
     void parseLayer(const std::string& id, const JSValue&, std::unique_ptr<Layer>&);
-    void parseVisibility(Layer&, const JSValue& value);
 
     std::unordered_map<std::string, const Source*> sourcesMap;
     std::unordered_map<std::string, std::pair<const JSValue&, std::unique_ptr<Layer>>> layersMap;
diff --git a/src/mbgl/style/rapidjson_conversion.hpp b/src/mbgl/style/rapidjson_conversion.hpp
index 1d9f88efa3..ecf044fb64 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -2,11 +2,16 @@
 
 #include <mbgl/util/rapidjson.hpp>
 #include <mbgl/util/feature.hpp>
+#include <mbgl/style/conversion.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();
 }
@@ -30,6 +35,17 @@ inline const JSValue* objectMember(const JSValue& value, const char * name) {
     return &value[name];
 }
 
+template <class Fn>
+optional<Error> eachMember(const JSValue& value, Fn&& fn) {
+    for (auto it = value.MemberBegin(); it != value.MemberEnd(); ++it) {
+        optional<Error> result = fn({it->name.GetString(), it->name.GetStringLength()}, it->value);
+        if (result) {
+            return result;
+        }
+    }
+    return {};
+}
+
 inline optional<bool> toBool(const JSValue& value) {
     if (!value.IsBool()) {
         return {};
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index cb48790c9f..9073894cc2 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -141,6 +141,8 @@ Layer* Style::getLayer(const std::string& id) const {
 }
 
 void Style::addLayer(std::unique_ptr<Layer> layer, optional<std::string> before) {
+    // TODO: verify source
+
     if (SymbolLayer* symbolLayer = layer->as<SymbolLayer>()) {
         if (!symbolLayer->impl->spriteAtlas) {
             symbolLayer->impl->spriteAtlas = spriteAtlas.get();
diff --git a/test/fixtures/style_parser/circle-blur.info.json b/test/fixtures/style_parser/circle-blur.info.json
index 60306e20c8..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-blur.info.json
+++ b/test/fixtures/style_parser/circle-blur.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "circle-blur: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/circle-blur.style.json b/test/fixtures/style_parser/circle-blur.style.json
index 8140ad5e47..9c82142c21 100644
--- a/test/fixtures/style_parser/circle-blur.style.json
+++ b/test/fixtures/style_parser/circle-blur.style.json
@@ -12,7 +12,7 @@
     "type": "circle",
     "source": "mapbox",
     "paint": {
-      "circle-blur": null
+      "circle-blur": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/circle-color.info.json b/test/fixtures/style_parser/circle-color.info.json
index 9d569ad53d..0dfa6371b7 100644
--- a/test/fixtures/style_parser/circle-color.info.json
+++ b/test/fixtures/style_parser/circle-color.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "circle-color: value must be a string"]
+            [1, "WARNING", "ParseStyle", "value must be a string"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/circle-color.style.json b/test/fixtures/style_parser/circle-color.style.json
index 44c32f99ce..e9c508304b 100644
--- a/test/fixtures/style_parser/circle-color.style.json
+++ b/test/fixtures/style_parser/circle-color.style.json
@@ -12,7 +12,7 @@
     "type": "circle",
     "source": "mapbox",
     "paint": {
-      "circle-color": null
+      "circle-color": 1
     }
   }]
 }
diff --git a/test/fixtures/style_parser/circle-opacity.info.json b/test/fixtures/style_parser/circle-opacity.info.json
index bb77cebd1e..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-opacity.info.json
+++ b/test/fixtures/style_parser/circle-opacity.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "circle-opacity: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/circle-opacity.style.json b/test/fixtures/style_parser/circle-opacity.style.json
index 601e81a51b..a993182b1b 100644
--- a/test/fixtures/style_parser/circle-opacity.style.json
+++ b/test/fixtures/style_parser/circle-opacity.style.json
@@ -12,7 +12,7 @@
     "type": "circle",
     "source": "mapbox",
     "paint": {
-      "circle-opacity": null
+      "circle-opacity": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/circle-radius.info.json b/test/fixtures/style_parser/circle-radius.info.json
index 285e962d74..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-radius.info.json
+++ b/test/fixtures/style_parser/circle-radius.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "circle-radius: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/circle-radius.style.json b/test/fixtures/style_parser/circle-radius.style.json
index a7fb28b2d3..f12cebff97 100644
--- a/test/fixtures/style_parser/circle-radius.style.json
+++ b/test/fixtures/style_parser/circle-radius.style.json
@@ -12,7 +12,7 @@
     "type": "circle",
     "source": "mapbox",
     "paint": {
-      "circle-radius": null
+      "circle-radius": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/function-numeric.info.json b/test/fixtures/style_parser/function-numeric.info.json
index 906cccf106..7dd5a69561 100644
--- a/test/fixtures/style_parser/function-numeric.info.json
+++ b/test/fixtures/style_parser/function-numeric.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-width: function stop must be an array"]
+            [1, "WARNING", "ParseStyle", "function stop must be an array"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/function-type.info.json b/test/fixtures/style_parser/function-type.info.json
index 8a844bf7c1..c9e26537f7 100644
--- a/test/fixtures/style_parser/function-type.info.json
+++ b/test/fixtures/style_parser/function-type.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-width: function value must specify stops"]
+            [1, "WARNING", "ParseStyle", "function value must specify stops"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/line-opacity.info.json b/test/fixtures/style_parser/line-opacity.info.json
index 63af59e280..40c4632c0e 100644
--- a/test/fixtures/style_parser/line-opacity.info.json
+++ b/test/fixtures/style_parser/line-opacity.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-opacity: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/line-opacity.style.json b/test/fixtures/style_parser/line-opacity.style.json
index 712b2b6f50..7d29fb312a 100644
--- a/test/fixtures/style_parser/line-opacity.style.json
+++ b/test/fixtures/style_parser/line-opacity.style.json
@@ -16,7 +16,7 @@
     "paint": {
       "line-color": "#008",
       "line-width": 0.9,
-      "line-opacity": null
+      "line-opacity": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/line-translate.info.json b/test/fixtures/style_parser/line-translate.info.json
index a23e17012e..16df094290 100644
--- a/test/fixtures/style_parser/line-translate.info.json
+++ b/test/fixtures/style_parser/line-translate.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-translate: value must be an array of two numbers"]
+            [1, "WARNING", "ParseStyle", "value must be an array of two numbers"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/line-translate.style.json b/test/fixtures/style_parser/line-translate.style.json
index a32b2d8ee4..4890a8b6df 100644
--- a/test/fixtures/style_parser/line-translate.style.json
+++ b/test/fixtures/style_parser/line-translate.style.json
@@ -12,7 +12,7 @@
     "type": "line",
     "source": "mapbox",
     "paint": {
-      "line-translate": null
+      "line-translate": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/line-width.info.json b/test/fixtures/style_parser/line-width.info.json
index 9e549a0228..40c4632c0e 100644
--- a/test/fixtures/style_parser/line-width.info.json
+++ b/test/fixtures/style_parser/line-width.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-width: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/line-width.style.json b/test/fixtures/style_parser/line-width.style.json
index e5fe6fa8e1..1f677460c4 100644
--- a/test/fixtures/style_parser/line-width.style.json
+++ b/test/fixtures/style_parser/line-width.style.json
@@ -14,7 +14,7 @@
     "source-layer": "waterway",
     "filter": ["in", "type", "river", "canal"],
     "paint": {
-      "line-width": null
+      "line-width": "no"
     }
   }]
 }
diff --git a/test/fixtures/style_parser/stop-zoom-value.info.json b/test/fixtures/style_parser/stop-zoom-value.info.json
index 3abf1867a4..386dce9d29 100644
--- a/test/fixtures/style_parser/stop-zoom-value.info.json
+++ b/test/fixtures/style_parser/stop-zoom-value.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "fill-opacity: function stop must have two elements"]
+            [1, "WARNING", "ParseStyle", "function stop must have two elements"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/stops-array.info.json b/test/fixtures/style_parser/stops-array.info.json
index b82f5a97d7..ed66513fee 100644
--- a/test/fixtures/style_parser/stops-array.info.json
+++ b/test/fixtures/style_parser/stops-array.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "line-width: function stops must be an array"]
+            [1, "WARNING", "ParseStyle", "function stops must be an array"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/text-size.info.json b/test/fixtures/style_parser/text-size.info.json
index b412c6beed..40c4632c0e 100644
--- a/test/fixtures/style_parser/text-size.info.json
+++ b/test/fixtures/style_parser/text-size.info.json
@@ -1,7 +1,7 @@
 {
     "default": {
         "log": [
-            [1, "WARNING", "ParseStyle", "text-size: value must be a number"]
+            [1, "WARNING", "ParseStyle", "value must be a number"]
         ]
     }
 }
diff --git a/test/fixtures/style_parser/text-size.style.json b/test/fixtures/style_parser/text-size.style.json
index ee6a6c39e4..dafa87d63b 100644
--- a/test/fixtures/style_parser/text-size.style.json
+++ b/test/fixtures/style_parser/text-size.style.json
@@ -14,7 +14,7 @@
     "source-layer": "country_label",
     "filter": ["==", "$type", "Point"],
     "layout": {
-      "text-size": null
+      "text-size": "no"
     }
   }]
 }