[core, node] Implement bindings for addLayer

35 files changed, 164 insertions, 287 deletions

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&);