[core] Immutable Impls

50 files changed, 1764 insertions, 1139 deletions

diff --git a/src/mbgl/style/layer.cpp b/src/mbgl/style/layer.cpp
index e2eba0e2e0..fe51dd09ca 100644
--- a/src/mbgl/style/layer.cpp
+++ b/src/mbgl/style/layer.cpp
@@ -1,16 +1,23 @@
 #include <mbgl/style/layer.hpp>
 #include <mbgl/style/layer_impl.hpp>
-#include <mbgl/style/layer_type.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
-Layer::Layer(LayerType type_, std::unique_ptr<Impl> baseImpl_)
-    : type(type_), baseImpl(std::move(baseImpl_)) {
+static LayerObserver nullObserver;
+
+Layer::Layer(Immutable<Impl> impl)
+    : baseImpl(std::move(impl)),
+      observer(&nullObserver) {
 }
 
 Layer::~Layer() = default;
 
+LayerType Layer::getType() const {
+    return baseImpl->type;
+}
+
 const std::string& Layer::getID() const {
     return baseImpl->id;
 }
@@ -19,27 +26,16 @@ VisibilityType Layer::getVisibility() const {
     return baseImpl->visibility;
 }
 
-void Layer::setVisibility(VisibilityType value) {
-    if (value == getVisibility())
-        return;
-    baseImpl->visibility = value;
-    baseImpl->observer->onLayerVisibilityChanged(*this);
-}
-
 float Layer::getMinZoom() const {
     return baseImpl->minZoom;
 }
 
-void Layer::setMinZoom(float minZoom) const {
-    baseImpl->minZoom = minZoom;
-}
-
 float Layer::getMaxZoom() const {
     return baseImpl->maxZoom;
 }
 
-void Layer::setMaxZoom(float maxZoom) const {
-    baseImpl->maxZoom = maxZoom;
+void Layer::setObserver(LayerObserver* observer_) {
+    observer = observer_ ? observer_ : &nullObserver;
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layer_impl.cpp b/src/mbgl/style/layer_impl.cpp
index 725064a9a2..a9a3941f3e 100644
--- a/src/mbgl/style/layer_impl.cpp
+++ b/src/mbgl/style/layer_impl.cpp
@@ -3,8 +3,10 @@
 namespace mbgl {
 namespace style {
 
-void Layer::Impl::setObserver(LayerObserver* observer_) {
-    observer = observer_ ? observer_ : &nullObserver;
+Layer::Impl::Impl(LayerType type_, std::string layerID, std::string sourceID)
+    : type(type_),
+      id(std::move(layerID)),
+      source(std::move(sourceID)) {
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp
index 914203f804..fe7259a11a 100644
--- a/src/mbgl/style/layer_impl.hpp
+++ b/src/mbgl/style/layer_impl.hpp
@@ -3,13 +3,10 @@
 #include <mbgl/style/layer.hpp>
 #include <mbgl/style/types.hpp>
 #include <mbgl/style/filter.hpp>
-#include <mbgl/style/layer_observer.hpp>
-#include <mbgl/util/noncopyable.hpp>
 
 #include <rapidjson/writer.h>
 #include <rapidjson/stringbuffer.h>
 
-#include <memory>
 #include <string>
 #include <limits>
 
@@ -30,24 +27,19 @@ namespace style {
  * Members that are public in `FooLayer::Impl` are part of the internal API for "foo" layers.
  * Members that are private in `FooLayer::Impl` are internal to "foo" layers.
  */
-class Layer::Impl {
+class Layer::Impl : public EnableImmutableFromThis<Layer::Impl> {
 public:
+    Impl(LayerType, std::string layerID, std::string sourceID);
     virtual ~Impl() = default;
 
-    // Create an identical copy of this layer.
-    virtual std::unique_ptr<Layer> clone() const = 0;
-
-    // Create a layer, copying all properties except id and paint properties from this layer.
-    virtual std::unique_ptr<Layer> cloneRef(const std::string& id) const = 0;
+    Impl& operator=(const Impl&) = delete;
 
     // Utility function for automatic layer grouping.
     virtual void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const = 0;
 
     virtual std::unique_ptr<RenderLayer> createRenderLayer() const = 0;
 
-    void setObserver(LayerObserver*);
-
-public:
+    const LayerType type;
     std::string id;
     std::string source;
     std::string sourceLayer;
@@ -56,13 +48,8 @@ public:
     float maxZoom = std::numeric_limits<float>::infinity();
     VisibilityType visibility = VisibilityType::Visible;
 
-    LayerObserver nullObserver;
-    LayerObserver* observer = &nullObserver;
-
 protected:
-    Impl() = default;
     Impl(const Impl&) = default;
-    Impl& operator=(const Impl&) = delete;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index b4ffea138b..3d29b9819c 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -3,38 +3,65 @@
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 BackgroundLayer::BackgroundLayer(const std::string& layerID)
-    : Layer(LayerType::Background, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
+    : Layer(makeMutable<Impl>(LayerType::Background, layerID, std::string())) {
 }
 
-BackgroundLayer::BackgroundLayer(const Impl& other)
-    : Layer(LayerType::Background, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+BackgroundLayer::BackgroundLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 BackgroundLayer::~BackgroundLayer() = default;
 
-std::unique_ptr<Layer> BackgroundLayer::Impl::clone() const {
-    return std::make_unique<BackgroundLayer>(*this);
+const BackgroundLayer::Impl& BackgroundLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = BackgroundPaintProperties::Cascading();
-    return std::move(result);
+Mutable<BackgroundLayer::Impl> BackgroundLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> BackgroundLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = BackgroundPaintProperties::Cascading();
+    return std::make_unique<BackgroundLayer>(std::move(impl_));
 }
 
 void BackgroundLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
 }
 
 
+// Visibility
+
+void BackgroundLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void BackgroundLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void BackgroundLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
+}
+
 // Layout properties
 
 
@@ -45,22 +72,26 @@ PropertyValue<Color> BackgroundLayer::getDefaultBackgroundColor() {
 }
 
 PropertyValue<Color> BackgroundLayer::getBackgroundColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundColor>().get(klass);
+    return impl().cascading.template get<BackgroundColor>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getBackgroundColor(klass))
         return;
-    impl->cascading.template get<BackgroundColor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundColor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<BackgroundColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions BackgroundLayer::getBackgroundColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundColor>().getTransition(klass);
+    return impl().cascading.template get<BackgroundColor>().getTransition(klass);
 }
 
 PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
@@ -68,22 +99,26 @@ PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
 }
 
 PropertyValue<std::string> BackgroundLayer::getBackgroundPattern(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundPattern>().get(klass);
+    return impl().cascading.template get<BackgroundPattern>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getBackgroundPattern(klass))
         return;
-    impl->cascading.template get<BackgroundPattern>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundPattern>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<BackgroundPattern>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundPattern>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions BackgroundLayer::getBackgroundPatternTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundPattern>().getTransition(klass);
+    return impl().cascading.template get<BackgroundPattern>().getTransition(klass);
 }
 
 PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
@@ -91,22 +126,26 @@ PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
 }
 
 PropertyValue<float> BackgroundLayer::getBackgroundOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundOpacity>().get(klass);
+    return impl().cascading.template get<BackgroundOpacity>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getBackgroundOpacity(klass))
         return;
-    impl->cascading.template get<BackgroundOpacity>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<BackgroundOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<BackgroundOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions BackgroundLayer::getBackgroundOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<BackgroundOpacity>().getTransition(klass);
+    return impl().cascading.template get<BackgroundOpacity>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/background_layer_impl.cpp b/src/mbgl/style/layers/background_layer_impl.cpp
index 6c4a4c26d9..07249ec5a4 100644
--- a/src/mbgl/style/layers/background_layer_impl.cpp
+++ b/src/mbgl/style/layers/background_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> BackgroundLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderBackgroundLayer>(*this);
+    return std::make_unique<RenderBackgroundLayer>(staticImmutableCast<BackgroundLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp
index 85152da4ec..41eee7bdf3 100644
--- a/src/mbgl/style/layers/background_layer_impl.hpp
+++ b/src/mbgl/style/layers/background_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class BackgroundLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 8b3431a9a1..6fcfe445a5 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/circle_layer.hpp>
 #include <mbgl/style/layers/circle_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 CircleLayer::CircleLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::Circle, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::Circle, layerID, sourceID)) {
 }
 
-CircleLayer::CircleLayer(const Impl& other)
-    : Layer(LayerType::Circle, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+CircleLayer::CircleLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 CircleLayer::~CircleLayer() = default;
 
-std::unique_ptr<Layer> CircleLayer::Impl::clone() const {
-    return std::make_unique<CircleLayer>(*this);
+const CircleLayer::Impl& CircleLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = CirclePaintProperties::Cascading();
-    return std::move(result);
+Mutable<CircleLayer::Impl> CircleLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> CircleLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = CirclePaintProperties::Cascading();
+    return std::make_unique<CircleLayer>(std::move(impl_));
 }
 
 void CircleLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
@@ -38,26 +39,55 @@ void CircleLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffe
 // Source
 
 const std::string& CircleLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 void CircleLayer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& CircleLayer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void CircleLayer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& CircleLayer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
+}
+
+// Visibility
+
+void CircleLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void CircleLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void CircleLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
 }
 
 // Layout properties
@@ -70,26 +100,30 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleRadius() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleRadius(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleRadius>().get(klass);
+    return impl().cascading.template get<CircleRadius>().get(klass);
 }
 
 void CircleLayer::setCircleRadius(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleRadius(klass))
         return;
-    impl->cascading.template get<CircleRadius>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleRadius>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleRadiusTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleRadius>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleRadius>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleRadiusTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleRadius>().getTransition(klass);
+    return impl().cascading.template get<CircleRadius>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() {
@@ -97,26 +131,30 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() {
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getCircleColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleColor>().get(klass);
+    return impl().cascading.template get<CircleColor>().get(klass);
 }
 
 void CircleLayer::setCircleColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getCircleColor(klass))
         return;
-    impl->cascading.template get<CircleColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleColor>().getTransition(klass);
+    return impl().cascading.template get<CircleColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() {
@@ -124,26 +162,30 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleBlur(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleBlur>().get(klass);
+    return impl().cascading.template get<CircleBlur>().get(klass);
 }
 
 void CircleLayer::setCircleBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleBlur(klass))
         return;
-    impl->cascading.template get<CircleBlur>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleBlur>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleBlur>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleBlur>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleBlurTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleBlur>().getTransition(klass);
+    return impl().cascading.template get<CircleBlur>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
@@ -151,26 +193,30 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleOpacity>().get(klass);
+    return impl().cascading.template get<CircleOpacity>().get(klass);
 }
 
 void CircleLayer::setCircleOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleOpacity(klass))
         return;
-    impl->cascading.template get<CircleOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleOpacity>().getTransition(klass);
+    return impl().cascading.template get<CircleOpacity>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
@@ -178,22 +224,26 @@ PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleTranslate>().get(klass);
+    return impl().cascading.template get<CircleTranslate>().get(klass);
 }
 
 void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getCircleTranslate(klass))
         return;
-    impl->cascading.template get<CircleTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCircleTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleTranslate>().getTransition(klass);
+    return impl().cascading.template get<CircleTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor() {
@@ -201,22 +251,26 @@ PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor(
 }
 
 PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleTranslateAnchor>().get(klass);
+    return impl().cascading.template get<CircleTranslateAnchor>().get(klass);
 }
 
 void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getCircleTranslateAnchor(klass))
         return;
-    impl->cascading.template get<CircleTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCircleTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<CircleTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
@@ -224,22 +278,26 @@ PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
 }
 
 PropertyValue<CirclePitchScaleType> CircleLayer::getCirclePitchScale(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CirclePitchScale>().get(klass);
+    return impl().cascading.template get<CirclePitchScale>().get(klass);
 }
 
 void CircleLayer::setCirclePitchScale(PropertyValue<CirclePitchScaleType> value, const optional<std::string>& klass) {
     if (value == getCirclePitchScale(klass))
         return;
-    impl->cascading.template get<CirclePitchScale>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CirclePitchScale>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCirclePitchScaleTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CirclePitchScale>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CirclePitchScale>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCirclePitchScaleTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CirclePitchScale>().getTransition(klass);
+    return impl().cascading.template get<CirclePitchScale>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
@@ -247,26 +305,30 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeWidth(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeWidth>().get(klass);
+    return impl().cascading.template get<CircleStrokeWidth>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeWidth(klass))
         return;
-    impl->cascading.template get<CircleStrokeWidth>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeWidth>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleStrokeWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleStrokeWidth>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeWidth>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleStrokeWidthTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeWidth>().getTransition(klass);
+    return impl().cascading.template get<CircleStrokeWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
@@ -274,26 +336,30 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getCircleStrokeColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeColor>().get(klass);
+    return impl().cascading.template get<CircleStrokeColor>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeColor(klass))
         return;
-    impl->cascading.template get<CircleStrokeColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleStrokeColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleStrokeColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleStrokeColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeColor>().getTransition(klass);
+    return impl().cascading.template get<CircleStrokeColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
@@ -301,26 +367,30 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeOpacity>().get(klass);
+    return impl().cascading.template get<CircleStrokeOpacity>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeOpacity(klass))
         return;
-    impl->cascading.template get<CircleStrokeOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void CircleLayer::setCircleStrokeOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<CircleStrokeOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<CircleStrokeOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions CircleLayer::getCircleStrokeOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<CircleStrokeOpacity>().getTransition(klass);
+    return impl().cascading.template get<CircleStrokeOpacity>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp
index 31b286f273..8df79507bf 100644
--- a/src/mbgl/style/layers/circle_layer_impl.cpp
+++ b/src/mbgl/style/layers/circle_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> CircleLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderCircleLayer>(*this);
+    return std::make_unique<RenderCircleLayer>(staticImmutableCast<CircleLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp
index 886815f0d1..94fa24b811 100644
--- a/src/mbgl/style/layers/circle_layer_impl.hpp
+++ b/src/mbgl/style/layers/circle_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class CircleLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp
index cda8a157f0..f7c349b3d8 100644
--- a/src/mbgl/style/layers/custom_layer.cpp
+++ b/src/mbgl/style/layers/custom_layer.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/style/layers/custom_layer_impl.hpp>
-#include <mbgl/util/logging.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
@@ -10,21 +10,52 @@ CustomLayer::CustomLayer(const std::string& layerID,
                          CustomLayerRenderFunction render,
                          CustomLayerDeinitializeFunction deinit,
                          void* context)
-    : Layer(LayerType::Custom, std::make_unique<Impl>(layerID, init, render, deinit, context))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    Log::Info(Event::General, "New custom layer: %s", layerID.c_str());
+    : Layer(makeMutable<Impl>(layerID, init, render, deinit, context)) {
 }
 
-CustomLayer::CustomLayer(const Impl& other)
-    : Layer(LayerType::Custom, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+CustomLayer::~CustomLayer() = default;
+
+const CustomLayer::Impl& CustomLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-CustomLayer::~CustomLayer() = default;
+Mutable<CustomLayer::Impl> CustomLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> CustomLayer::cloneRef(const std::string&) const {
+    assert(false);
+    return nullptr;
+}
+
+// Visibility
+
+void CustomLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void CustomLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void CustomLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
+}
 
 template <>
 bool Layer::is<CustomLayer>() const {
-    return type == LayerType::Custom;
+    return getType() == LayerType::Custom;
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/custom_layer_impl.cpp b/src/mbgl/style/layers/custom_layer_impl.cpp
index 1d3e9af8d6..e459b57171 100644
--- a/src/mbgl/style/layers/custom_layer_impl.cpp
+++ b/src/mbgl/style/layers/custom_layer_impl.cpp
@@ -2,52 +2,36 @@
 #include <mbgl/renderer/render_custom_layer.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/util/logging.hpp>
+
 namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> CustomLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderCustomLayer>(*this);
+    return std::make_unique<RenderCustomLayer>(staticImmutableCast<CustomLayer::Impl>(immutableFromThis()));
 }
 
 CustomLayer::Impl::Impl(const std::string& id_,
                          CustomLayerInitializeFunction initializeFn_,
                          CustomLayerRenderFunction renderFn_,
                          CustomLayerDeinitializeFunction deinitializeFn_,
-                         void* context_) {
+                         void* context_)
+    : Layer::Impl(LayerType::Custom, id_, std::string()) {
     Log::Info(Event::General, "New custom layer Impl: %s", id_.c_str());
-    id = id_;
     initializeFn = initializeFn_;
     renderFn = renderFn_;
     deinitializeFn = deinitializeFn_;
     context = context_;
 }
 
-CustomLayer::Impl::Impl(const CustomLayer::Impl &other)
-        : Layer::Impl(other) {
-    id = other.id;
-    // Don't copy anything else.
-}
-
-CustomLayer::Impl::~Impl() = default;
-
-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::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
 }
 
-void CustomLayer::Impl::initialize() {
+void CustomLayer::Impl::initialize() const {
     assert(initializeFn);
     initializeFn(context);
 }
 
-void CustomLayer::Impl::deinitialize() {
+void CustomLayer::Impl::deinitialize() const {
     if (deinitializeFn) {
         deinitializeFn(context);
     }
diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp
index e612d17f14..f921f47d59 100644
--- a/src/mbgl/style/layers/custom_layer_impl.hpp
+++ b/src/mbgl/style/layers/custom_layer_impl.hpp
@@ -17,16 +17,11 @@ public:
          CustomLayerDeinitializeFunction,
          void* context);
 
-    Impl(const Impl&);
-    ~Impl() final;
-
-    void initialize();
-    void deinitialize();
+    void initialize() const;
+    void deinitialize() const;
     void render(const TransformState&) const;
 
 private:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const final;
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index 6f11d6052c..78a348f5c4 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/fill_extrusion_layer.hpp>
 #include <mbgl/style/layers/fill_extrusion_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 FillExtrusionLayer::FillExtrusionLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::FillExtrusion, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::FillExtrusion, layerID, sourceID)) {
 }
 
-FillExtrusionLayer::FillExtrusionLayer(const Impl& other)
-    : Layer(LayerType::FillExtrusion, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+FillExtrusionLayer::FillExtrusionLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 FillExtrusionLayer::~FillExtrusionLayer() = default;
 
-std::unique_ptr<Layer> FillExtrusionLayer::Impl::clone() const {
-    return std::make_unique<FillExtrusionLayer>(*this);
+const FillExtrusionLayer::Impl& FillExtrusionLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Layer> FillExtrusionLayer::Impl::cloneRef(const std::string& id_) const {
-    auto result = std::make_unique<FillExtrusionLayer>(*this);
-    result->impl->id = id_;
-    result->impl->cascading = FillExtrusionPaintProperties::Cascading();
-    return std::move(result);
+Mutable<FillExtrusionLayer::Impl> FillExtrusionLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> FillExtrusionLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = FillExtrusionPaintProperties::Cascading();
+    return std::make_unique<FillExtrusionLayer>(std::move(impl_));
 }
 
 void FillExtrusionLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
@@ -38,26 +39,55 @@ void FillExtrusionLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::Stri
 // Source
 
 const std::string& FillExtrusionLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 void FillExtrusionLayer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& FillExtrusionLayer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void FillExtrusionLayer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& FillExtrusionLayer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
+}
+
+// Visibility
+
+void FillExtrusionLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void FillExtrusionLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void FillExtrusionLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
 }
 
 // Layout properties
@@ -70,22 +100,26 @@ PropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionOpacity() {
 }
 
 PropertyValue<float> FillExtrusionLayer::getFillExtrusionOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionOpacity>().get(klass);
+    return impl().cascading.template get<FillExtrusionOpacity>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionOpacity(klass))
         return;
-    impl->cascading.template get<FillExtrusionOpacity>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionOpacity>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor() {
@@ -93,26 +127,30 @@ DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor(
 }
 
 DataDrivenPropertyValue<Color> FillExtrusionLayer::getFillExtrusionColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionColor>().get(klass);
+    return impl().cascading.template get<FillExtrusionColor>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionColor(klass))
         return;
-    impl->cascading.template get<FillExtrusionColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillExtrusionLayer::setFillExtrusionColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionColor>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionTranslate() {
@@ -120,22 +158,26 @@ PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionT
 }
 
 PropertyValue<std::array<float, 2>> FillExtrusionLayer::getFillExtrusionTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionTranslate>().get(klass);
+    return impl().cascading.template get<FillExtrusionTranslate>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionTranslate(klass))
         return;
-    impl->cascading.template get<FillExtrusionTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionTranslate>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTranslateAnchor() {
@@ -143,22 +185,26 @@ PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTr
 }
 
 PropertyValue<TranslateAnchorType> FillExtrusionLayer::getFillExtrusionTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionTranslateAnchor>().get(klass);
+    return impl().cascading.template get<FillExtrusionTranslateAnchor>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionTranslateAnchor(klass))
         return;
-    impl->cascading.template get<FillExtrusionTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern() {
@@ -166,22 +212,26 @@ PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern()
 }
 
 PropertyValue<std::string> FillExtrusionLayer::getFillExtrusionPattern(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionPattern>().get(klass);
+    return impl().cascading.template get<FillExtrusionPattern>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionPattern(klass))
         return;
-    impl->cascading.template get<FillExtrusionPattern>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionPattern>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionPattern>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionPattern>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionPatternTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionPattern>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionPattern>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight() {
@@ -189,26 +239,30 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionHeight(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionHeight>().get(klass);
+    return impl().cascading.template get<FillExtrusionHeight>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionHeight(klass))
         return;
-    impl->cascading.template get<FillExtrusionHeight>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionHeight>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillExtrusionLayer::setFillExtrusionHeightTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionHeight>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionHeight>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionHeightTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionHeight>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionHeight>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() {
@@ -216,26 +270,30 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase()
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionBase(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionBase>().get(klass);
+    return impl().cascading.template get<FillExtrusionBase>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionBase(klass))
         return;
-    impl->cascading.template get<FillExtrusionBase>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionBase>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillExtrusionLayer::setFillExtrusionBaseTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillExtrusionBase>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillExtrusionBase>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillExtrusionBase>().getTransition(klass);
+    return impl().cascading.template get<FillExtrusionBase>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp b/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp
index 5340541221..9530e45b7f 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> FillExtrusionLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderFillExtrusionLayer>(*this);
+    return std::make_unique<RenderFillExtrusionLayer>(staticImmutableCast<FillExtrusionLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp b/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp
index 2353bd99fe..167d28e973 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class FillExtrusionLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 9fd9d33af3..39f476c974 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/fill_layer.hpp>
 #include <mbgl/style/layers/fill_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 FillLayer::FillLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::Fill, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::Fill, layerID, sourceID)) {
 }
 
-FillLayer::FillLayer(const Impl& other)
-    : Layer(LayerType::Fill, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+FillLayer::FillLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 FillLayer::~FillLayer() = default;
 
-std::unique_ptr<Layer> FillLayer::Impl::clone() const {
-    return std::make_unique<FillLayer>(*this);
+const FillLayer::Impl& FillLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = FillPaintProperties::Cascading();
-    return std::move(result);
+Mutable<FillLayer::Impl> FillLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> FillLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = FillPaintProperties::Cascading();
+    return std::make_unique<FillLayer>(std::move(impl_));
 }
 
 void FillLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
@@ -38,26 +39,55 @@ void FillLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>
 // Source
 
 const std::string& FillLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 void FillLayer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& FillLayer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void FillLayer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& FillLayer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
+}
+
+// Visibility
+
+void FillLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void FillLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void FillLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
 }
 
 // Layout properties
@@ -70,22 +100,26 @@ PropertyValue<bool> FillLayer::getDefaultFillAntialias() {
 }
 
 PropertyValue<bool> FillLayer::getFillAntialias(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillAntialias>().get(klass);
+    return impl().cascading.template get<FillAntialias>().get(klass);
 }
 
 void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) {
     if (value == getFillAntialias(klass))
         return;
-    impl->cascading.template get<FillAntialias>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillAntialias>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillAntialiasTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillAntialias>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillAntialias>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillAntialiasTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillAntialias>().getTransition(klass);
+    return impl().cascading.template get<FillAntialias>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() {
@@ -93,26 +127,30 @@ DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() {
 }
 
 DataDrivenPropertyValue<float> FillLayer::getFillOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillOpacity>().get(klass);
+    return impl().cascading.template get<FillOpacity>().get(klass);
 }
 
 void FillLayer::setFillOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillOpacity(klass))
         return;
-    impl->cascading.template get<FillOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillLayer::setFillOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillOpacity>().getTransition(klass);
+    return impl().cascading.template get<FillOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() {
@@ -120,26 +158,30 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() {
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getFillColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillColor>().get(klass);
+    return impl().cascading.template get<FillColor>().get(klass);
 }
 
 void FillLayer::setFillColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillColor(klass))
         return;
-    impl->cascading.template get<FillColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillLayer::setFillColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillColor>().getTransition(klass);
+    return impl().cascading.template get<FillColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
@@ -147,26 +189,30 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getFillOutlineColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillOutlineColor>().get(klass);
+    return impl().cascading.template get<FillOutlineColor>().get(klass);
 }
 
 void FillLayer::setFillOutlineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillOutlineColor(klass))
         return;
-    impl->cascading.template get<FillOutlineColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillOutlineColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void FillLayer::setFillOutlineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillOutlineColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillOutlineColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillOutlineColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillOutlineColor>().getTransition(klass);
+    return impl().cascading.template get<FillOutlineColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
@@ -174,22 +220,26 @@ PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillTranslate>().get(klass);
+    return impl().cascading.template get<FillTranslate>().get(klass);
 }
 
 void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getFillTranslate(klass))
         return;
-    impl->cascading.template get<FillTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillTranslate>().getTransition(klass);
+    return impl().cascading.template get<FillTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
@@ -197,22 +247,26 @@ PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
 }
 
 PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillTranslateAnchor>().get(klass);
+    return impl().cascading.template get<FillTranslateAnchor>().get(klass);
 }
 
 void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getFillTranslateAnchor(klass))
         return;
-    impl->cascading.template get<FillTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<FillTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
@@ -220,22 +274,26 @@ PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
 }
 
 PropertyValue<std::string> FillLayer::getFillPattern(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillPattern>().get(klass);
+    return impl().cascading.template get<FillPattern>().get(klass);
 }
 
 void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getFillPattern(klass))
         return;
-    impl->cascading.template get<FillPattern>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillPattern>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<FillPattern>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<FillPattern>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions FillLayer::getFillPatternTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<FillPattern>().getTransition(klass);
+    return impl().cascading.template get<FillPattern>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp
index 6ec55a58e3..3bddedbdfb 100644
--- a/src/mbgl/style/layers/fill_layer_impl.cpp
+++ b/src/mbgl/style/layers/fill_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> FillLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderFillLayer>(*this);
+    return std::make_unique<RenderFillLayer>(staticImmutableCast<FillLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp
index 215558962e..0e911c86cf 100644
--- a/src/mbgl/style/layers/fill_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class FillLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 2f690c3158..31a4332400 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -8,41 +8,40 @@
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer.hpp>
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 <% if (type === 'background') { -%>
 <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
+    : Layer(makeMutable<Impl>(LayerType::<%- camelize(type) %>, layerID, std::string())) {
 }
 <% } else { -%>
 <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::<%- camelize(type) %>, layerID, sourceID)) {
 }
 <% } -%>
 
-<%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const Impl& other)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+<%- camelize(type) %>Layer::<%- camelize(type) %>Layer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
 
-std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::clone() const {
-    return std::make_unique<<%- camelize(type) %>Layer>(*this);
+const <%- camelize(type) %>Layer::Impl& <%- camelize(type) %>Layer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = <%- camelize(type) %>PaintProperties::Cascading();
-    return std::move(result);
+Mutable<<%- camelize(type) %>Layer::Impl> <%- camelize(type) %>Layer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> <%- camelize(type) %>Layer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = <%- camelize(type) %>PaintProperties::Cascading();
+    return std::make_unique<<%- camelize(type) %>Layer>(std::move(impl_));
 }
 
 <% if (layoutProperties.length) { -%>
@@ -58,31 +57,60 @@ void <%- camelize(type) %>Layer::Impl::stringifyLayout(rapidjson::Writer<rapidjs
 // Source
 
 const std::string& <%- camelize(type) %>Layer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 <% if (type !== 'raster') { -%>
 void <%- camelize(type) %>Layer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& <%- camelize(type) %>Layer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void <%- camelize(type) %>Layer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& <%- camelize(type) %>Layer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
 }
 <% } -%>
 <% } -%>
 
+// Visibility
+
+void <%- camelize(type) %>Layer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void <%- camelize(type) %>Layer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void <%- camelize(type) %>Layer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
+}
+
 // Layout properties
 
 <% for (const property of layoutProperties) { -%>
@@ -91,14 +119,16 @@ const Filter& <%- camelize(type) %>Layer::getFilter() const {
 }
 
 <%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
-    return impl->layout.unevaluated.get<<%- camelize(property.name) %>>();
+    return impl().layout.unevaluated.get<<%- camelize(property.name) %>>();
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value) {
     if (value == get<%- camelize(property.name) %>())
         return;
-    impl->layout.unevaluated.get<<%- camelize(property.name) %>>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "<%- property.name %>");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<<%- camelize(property.name) %>>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "<%- property.name %>");
 }
 <% } -%>
 
@@ -109,30 +139,34 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV
 }
 
 <%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(const optional<std::string>& klass) const {
-    return impl->cascading.template get<<%- camelize(property.name) %>>().get(klass);
+    return impl().cascading.template get<<%- camelize(property.name) %>>().get(klass);
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value, const optional<std::string>& klass) {
     if (value == get<%- camelize(property.name) %>(klass))
         return;
-    impl->cascading.template get<<%- camelize(property.name) %>>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<<%- camelize(property.name) %>>().set(value, klass);
+    baseImpl = std::move(impl_);
 <% if (isDataDriven(property)) { -%>
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 <% } else { -%>
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    observer->onLayerPaintPropertyChanged(*this);
 <% } -%>
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<<%- camelize(property.name) %>>().getTransition(klass);
+    return impl().cascading.template get<<%- camelize(property.name) %>>().getTransition(klass);
 }
 <% } -%>
 
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index 7f1575aad5..8b9085b48c 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 LineLayer::LineLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::Line, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::Line, layerID, sourceID)) {
 }
 
-LineLayer::LineLayer(const Impl& other)
-    : Layer(LayerType::Line, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+LineLayer::LineLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 LineLayer::~LineLayer() = default;
 
-std::unique_ptr<Layer> LineLayer::Impl::clone() const {
-    return std::make_unique<LineLayer>(*this);
+const LineLayer::Impl& LineLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = LinePaintProperties::Cascading();
-    return std::move(result);
+Mutable<LineLayer::Impl> LineLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> LineLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = LinePaintProperties::Cascading();
+    return std::make_unique<LineLayer>(std::move(impl_));
 }
 
 void LineLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>& writer) const {
@@ -39,26 +40,55 @@ void LineLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>
 // Source
 
 const std::string& LineLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 void LineLayer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& LineLayer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void LineLayer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& LineLayer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
+}
+
+// Visibility
+
+void LineLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void LineLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void LineLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
 }
 
 // Layout properties
@@ -68,56 +98,64 @@ PropertyValue<LineCapType> LineLayer::getDefaultLineCap() {
 }
 
 PropertyValue<LineCapType> LineLayer::getLineCap() const {
-    return impl->layout.unevaluated.get<LineCap>();
+    return impl().layout.unevaluated.get<LineCap>();
 }
 
 void LineLayer::setLineCap(PropertyValue<LineCapType> value) {
     if (value == getLineCap())
         return;
-    impl->layout.unevaluated.get<LineCap>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "line-cap");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<LineCap>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "line-cap");
 }
 PropertyValue<LineJoinType> LineLayer::getDefaultLineJoin() {
     return LineJoin::defaultValue();
 }
 
 PropertyValue<LineJoinType> LineLayer::getLineJoin() const {
-    return impl->layout.unevaluated.get<LineJoin>();
+    return impl().layout.unevaluated.get<LineJoin>();
 }
 
 void LineLayer::setLineJoin(PropertyValue<LineJoinType> value) {
     if (value == getLineJoin())
         return;
-    impl->layout.unevaluated.get<LineJoin>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "line-join");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<LineJoin>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "line-join");
 }
 PropertyValue<float> LineLayer::getDefaultLineMiterLimit() {
     return LineMiterLimit::defaultValue();
 }
 
 PropertyValue<float> LineLayer::getLineMiterLimit() const {
-    return impl->layout.unevaluated.get<LineMiterLimit>();
+    return impl().layout.unevaluated.get<LineMiterLimit>();
 }
 
 void LineLayer::setLineMiterLimit(PropertyValue<float> value) {
     if (value == getLineMiterLimit())
         return;
-    impl->layout.unevaluated.get<LineMiterLimit>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "line-miter-limit");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<LineMiterLimit>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "line-miter-limit");
 }
 PropertyValue<float> LineLayer::getDefaultLineRoundLimit() {
     return LineRoundLimit::defaultValue();
 }
 
 PropertyValue<float> LineLayer::getLineRoundLimit() const {
-    return impl->layout.unevaluated.get<LineRoundLimit>();
+    return impl().layout.unevaluated.get<LineRoundLimit>();
 }
 
 void LineLayer::setLineRoundLimit(PropertyValue<float> value) {
     if (value == getLineRoundLimit())
         return;
-    impl->layout.unevaluated.get<LineRoundLimit>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "line-round-limit");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<LineRoundLimit>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "line-round-limit");
 }
 
 // Paint properties
@@ -127,26 +165,30 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOpacity() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineOpacity>().get(klass);
+    return impl().cascading.template get<LineOpacity>().get(klass);
 }
 
 void LineLayer::setLineOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineOpacity(klass))
         return;
-    impl->cascading.template get<LineOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void LineLayer::setLineOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineOpacity>().getTransition(klass);
+    return impl().cascading.template get<LineOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() {
@@ -154,26 +196,30 @@ DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() {
 }
 
 DataDrivenPropertyValue<Color> LineLayer::getLineColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineColor>().get(klass);
+    return impl().cascading.template get<LineColor>().get(klass);
 }
 
 void LineLayer::setLineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getLineColor(klass))
         return;
-    impl->cascading.template get<LineColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void LineLayer::setLineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineColor>().getTransition(klass);
+    return impl().cascading.template get<LineColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
@@ -181,22 +227,26 @@ PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineTranslate>().get(klass);
+    return impl().cascading.template get<LineTranslate>().get(klass);
 }
 
 void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getLineTranslate(klass))
         return;
-    impl->cascading.template get<LineTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineTranslate>().getTransition(klass);
+    return impl().cascading.template get<LineTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
@@ -204,22 +254,26 @@ PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
 }
 
 PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineTranslateAnchor>().get(klass);
+    return impl().cascading.template get<LineTranslateAnchor>().get(klass);
 }
 
 void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getLineTranslateAnchor(klass))
         return;
-    impl->cascading.template get<LineTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<LineTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<float> LineLayer::getDefaultLineWidth() {
@@ -227,22 +281,26 @@ PropertyValue<float> LineLayer::getDefaultLineWidth() {
 }
 
 PropertyValue<float> LineLayer::getLineWidth(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineWidth>().get(klass);
+    return impl().cascading.template get<LineWidth>().get(klass);
 }
 
 void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineWidth(klass))
         return;
-    impl->cascading.template get<LineWidth>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineWidth>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineWidth>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineWidth>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineWidthTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineWidth>().getTransition(klass);
+    return impl().cascading.template get<LineWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() {
@@ -250,26 +308,30 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineGapWidth(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineGapWidth>().get(klass);
+    return impl().cascading.template get<LineGapWidth>().get(klass);
 }
 
 void LineLayer::setLineGapWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineGapWidth(klass))
         return;
-    impl->cascading.template get<LineGapWidth>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineGapWidth>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void LineLayer::setLineGapWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineGapWidth>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineGapWidth>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineGapWidthTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineGapWidth>().getTransition(klass);
+    return impl().cascading.template get<LineGapWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() {
@@ -277,26 +339,30 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineOffset(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineOffset>().get(klass);
+    return impl().cascading.template get<LineOffset>().get(klass);
 }
 
 void LineLayer::setLineOffset(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineOffset(klass))
         return;
-    impl->cascading.template get<LineOffset>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineOffset>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void LineLayer::setLineOffsetTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineOffset>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineOffset>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineOffsetTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineOffset>().getTransition(klass);
+    return impl().cascading.template get<LineOffset>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() {
@@ -304,26 +370,30 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineBlur(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineBlur>().get(klass);
+    return impl().cascading.template get<LineBlur>().get(klass);
 }
 
 void LineLayer::setLineBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineBlur(klass))
         return;
-    impl->cascading.template get<LineBlur>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineBlur>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void LineLayer::setLineBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineBlur>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineBlur>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineBlurTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineBlur>().getTransition(klass);
+    return impl().cascading.template get<LineBlur>().getTransition(klass);
 }
 
 PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
@@ -331,22 +401,26 @@ PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
 }
 
 PropertyValue<std::vector<float>> LineLayer::getLineDasharray(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineDasharray>().get(klass);
+    return impl().cascading.template get<LineDasharray>().get(klass);
 }
 
 void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) {
     if (value == getLineDasharray(klass))
         return;
-    impl->cascading.template get<LineDasharray>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineDasharray>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineDasharrayTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LineDasharray>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LineDasharray>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLineDasharrayTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LineDasharray>().getTransition(klass);
+    return impl().cascading.template get<LineDasharray>().getTransition(klass);
 }
 
 PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
@@ -354,22 +428,26 @@ PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
 }
 
 PropertyValue<std::string> LineLayer::getLinePattern(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LinePattern>().get(klass);
+    return impl().cascading.template get<LinePattern>().get(klass);
 }
 
 void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getLinePattern(klass))
         return;
-    impl->cascading.template get<LinePattern>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LinePattern>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLinePatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<LinePattern>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<LinePattern>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions LineLayer::getLinePatternTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<LinePattern>().getTransition(klass);
+    return impl().cascading.template get<LinePattern>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp
index 973a77abf4..0158ba7a96 100644
--- a/src/mbgl/style/layers/line_layer_impl.cpp
+++ b/src/mbgl/style/layers/line_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> LineLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderLineLayer>(*this);
+    return std::make_unique<RenderLineLayer>(staticImmutableCast<LineLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp
index 02c9c85f00..70d357c592 100644
--- a/src/mbgl/style/layers/line_layer_impl.hpp
+++ b/src/mbgl/style/layers/line_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class LineLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index b525f9eaa4..13c2d214ce 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/raster_layer.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 RasterLayer::RasterLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::Raster, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::Raster, layerID, sourceID)) {
 }
 
-RasterLayer::RasterLayer(const Impl& other)
-    : Layer(LayerType::Raster, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+RasterLayer::RasterLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 RasterLayer::~RasterLayer() = default;
 
-std::unique_ptr<Layer> RasterLayer::Impl::clone() const {
-    return std::make_unique<RasterLayer>(*this);
+const RasterLayer::Impl& RasterLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = RasterPaintProperties::Cascading();
-    return std::move(result);
+Mutable<RasterLayer::Impl> RasterLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> RasterLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = RasterPaintProperties::Cascading();
+    return std::make_unique<RasterLayer>(std::move(impl_));
 }
 
 void RasterLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const {
@@ -38,10 +39,35 @@ void RasterLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffe
 // Source
 
 const std::string& RasterLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 
+// Visibility
+
+void RasterLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void RasterLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void RasterLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
+}
+
 // Layout properties
 
 
@@ -52,22 +78,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterOpacity() {
 }
 
 PropertyValue<float> RasterLayer::getRasterOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterOpacity>().get(klass);
+    return impl().cascading.template get<RasterOpacity>().get(klass);
 }
 
 void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterOpacity(klass))
         return;
-    impl->cascading.template get<RasterOpacity>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterOpacity>().getTransition(klass);
+    return impl().cascading.template get<RasterOpacity>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
@@ -75,22 +105,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
 }
 
 PropertyValue<float> RasterLayer::getRasterHueRotate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterHueRotate>().get(klass);
+    return impl().cascading.template get<RasterHueRotate>().get(klass);
 }
 
 void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterHueRotate(klass))
         return;
-    impl->cascading.template get<RasterHueRotate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterHueRotate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterHueRotate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterHueRotate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterHueRotateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterHueRotate>().getTransition(klass);
+    return impl().cascading.template get<RasterHueRotate>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
@@ -98,22 +132,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
 }
 
 PropertyValue<float> RasterLayer::getRasterBrightnessMin(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterBrightnessMin>().get(klass);
+    return impl().cascading.template get<RasterBrightnessMin>().get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterBrightnessMin(klass))
         return;
-    impl->cascading.template get<RasterBrightnessMin>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterBrightnessMin>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterBrightnessMin>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterBrightnessMin>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterBrightnessMinTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterBrightnessMin>().getTransition(klass);
+    return impl().cascading.template get<RasterBrightnessMin>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
@@ -121,22 +159,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
 }
 
 PropertyValue<float> RasterLayer::getRasterBrightnessMax(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterBrightnessMax>().get(klass);
+    return impl().cascading.template get<RasterBrightnessMax>().get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterBrightnessMax(klass))
         return;
-    impl->cascading.template get<RasterBrightnessMax>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterBrightnessMax>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterBrightnessMax>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterBrightnessMax>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterBrightnessMaxTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterBrightnessMax>().getTransition(klass);
+    return impl().cascading.template get<RasterBrightnessMax>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
@@ -144,22 +186,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
 }
 
 PropertyValue<float> RasterLayer::getRasterSaturation(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterSaturation>().get(klass);
+    return impl().cascading.template get<RasterSaturation>().get(klass);
 }
 
 void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterSaturation(klass))
         return;
-    impl->cascading.template get<RasterSaturation>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterSaturation>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterSaturation>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterSaturation>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterSaturationTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterSaturation>().getTransition(klass);
+    return impl().cascading.template get<RasterSaturation>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
@@ -167,22 +213,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
 }
 
 PropertyValue<float> RasterLayer::getRasterContrast(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterContrast>().get(klass);
+    return impl().cascading.template get<RasterContrast>().get(klass);
 }
 
 void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterContrast(klass))
         return;
-    impl->cascading.template get<RasterContrast>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterContrast>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterContrast>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterContrast>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterContrastTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterContrast>().getTransition(klass);
+    return impl().cascading.template get<RasterContrast>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
@@ -190,22 +240,26 @@ PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
 }
 
 PropertyValue<float> RasterLayer::getRasterFadeDuration(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterFadeDuration>().get(klass);
+    return impl().cascading.template get<RasterFadeDuration>().get(klass);
 }
 
 void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterFadeDuration(klass))
         return;
-    impl->cascading.template get<RasterFadeDuration>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterFadeDuration>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<RasterFadeDuration>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<RasterFadeDuration>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions RasterLayer::getRasterFadeDurationTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<RasterFadeDuration>().getTransition(klass);
+    return impl().cascading.template get<RasterFadeDuration>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp
index fa9f80dac6..f7e908a5cf 100644
--- a/src/mbgl/style/layers/raster_layer_impl.cpp
+++ b/src/mbgl/style/layers/raster_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> RasterLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderRasterLayer>(*this);
+    return std::make_unique<RenderRasterLayer>(staticImmutableCast<RasterLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp
index edf5f9111b..451619807a 100644
--- a/src/mbgl/style/layers/raster_layer_impl.hpp
+++ b/src/mbgl/style/layers/raster_layer_impl.hpp
@@ -9,8 +9,8 @@ namespace style {
 
 class RasterLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 273a9fd24e..5a062997c4 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -3,33 +3,34 @@
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 SymbolLayer::SymbolLayer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::Symbol, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::Symbol, layerID, sourceID)) {
 }
 
-SymbolLayer::SymbolLayer(const Impl& other)
-    : Layer(LayerType::Symbol, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+SymbolLayer::SymbolLayer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 SymbolLayer::~SymbolLayer() = default;
 
-std::unique_ptr<Layer> SymbolLayer::Impl::clone() const {
-    return std::make_unique<SymbolLayer>(*this);
+const SymbolLayer::Impl& SymbolLayer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-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->cascading = SymbolPaintProperties::Cascading();
-    return std::move(result);
+Mutable<SymbolLayer::Impl> SymbolLayer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> SymbolLayer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = SymbolPaintProperties::Cascading();
+    return std::make_unique<SymbolLayer>(std::move(impl_));
 }
 
 void SymbolLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>& writer) const {
@@ -39,26 +40,55 @@ void SymbolLayer::Impl::stringifyLayout(rapidjson::Writer<rapidjson::StringBuffe
 // Source
 
 const std::string& SymbolLayer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 void SymbolLayer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& SymbolLayer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void SymbolLayer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& SymbolLayer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
+}
+
+// Visibility
+
+void SymbolLayer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void SymbolLayer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void SymbolLayer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
 }
 
 // Layout properties
@@ -68,476 +98,544 @@ PropertyValue<SymbolPlacementType> SymbolLayer::getDefaultSymbolPlacement() {
 }
 
 PropertyValue<SymbolPlacementType> SymbolLayer::getSymbolPlacement() const {
-    return impl->layout.unevaluated.get<SymbolPlacement>();
+    return impl().layout.unevaluated.get<SymbolPlacement>();
 }
 
 void SymbolLayer::setSymbolPlacement(PropertyValue<SymbolPlacementType> value) {
     if (value == getSymbolPlacement())
         return;
-    impl->layout.unevaluated.get<SymbolPlacement>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-placement");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<SymbolPlacement>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "symbol-placement");
 }
 PropertyValue<float> SymbolLayer::getDefaultSymbolSpacing() {
     return SymbolSpacing::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getSymbolSpacing() const {
-    return impl->layout.unevaluated.get<SymbolSpacing>();
+    return impl().layout.unevaluated.get<SymbolSpacing>();
 }
 
 void SymbolLayer::setSymbolSpacing(PropertyValue<float> value) {
     if (value == getSymbolSpacing())
         return;
-    impl->layout.unevaluated.get<SymbolSpacing>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-spacing");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<SymbolSpacing>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "symbol-spacing");
 }
 PropertyValue<bool> SymbolLayer::getDefaultSymbolAvoidEdges() {
     return SymbolAvoidEdges::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getSymbolAvoidEdges() const {
-    return impl->layout.unevaluated.get<SymbolAvoidEdges>();
+    return impl().layout.unevaluated.get<SymbolAvoidEdges>();
 }
 
 void SymbolLayer::setSymbolAvoidEdges(PropertyValue<bool> value) {
     if (value == getSymbolAvoidEdges())
         return;
-    impl->layout.unevaluated.get<SymbolAvoidEdges>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-avoid-edges");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<SymbolAvoidEdges>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "symbol-avoid-edges");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconAllowOverlap() {
     return IconAllowOverlap::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconAllowOverlap() const {
-    return impl->layout.unevaluated.get<IconAllowOverlap>();
+    return impl().layout.unevaluated.get<IconAllowOverlap>();
 }
 
 void SymbolLayer::setIconAllowOverlap(PropertyValue<bool> value) {
     if (value == getIconAllowOverlap())
         return;
-    impl->layout.unevaluated.get<IconAllowOverlap>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-allow-overlap");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconAllowOverlap>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-allow-overlap");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconIgnorePlacement() {
     return IconIgnorePlacement::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconIgnorePlacement() const {
-    return impl->layout.unevaluated.get<IconIgnorePlacement>();
+    return impl().layout.unevaluated.get<IconIgnorePlacement>();
 }
 
 void SymbolLayer::setIconIgnorePlacement(PropertyValue<bool> value) {
     if (value == getIconIgnorePlacement())
         return;
-    impl->layout.unevaluated.get<IconIgnorePlacement>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-ignore-placement");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconIgnorePlacement>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-ignore-placement");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconOptional() {
     return IconOptional::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconOptional() const {
-    return impl->layout.unevaluated.get<IconOptional>();
+    return impl().layout.unevaluated.get<IconOptional>();
 }
 
 void SymbolLayer::setIconOptional(PropertyValue<bool> value) {
     if (value == getIconOptional())
         return;
-    impl->layout.unevaluated.get<IconOptional>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-optional");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconOptional>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-optional");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultIconRotationAlignment() {
     return IconRotationAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getIconRotationAlignment() const {
-    return impl->layout.unevaluated.get<IconRotationAlignment>();
+    return impl().layout.unevaluated.get<IconRotationAlignment>();
 }
 
 void SymbolLayer::setIconRotationAlignment(PropertyValue<AlignmentType> value) {
     if (value == getIconRotationAlignment())
         return;
-    impl->layout.unevaluated.get<IconRotationAlignment>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-rotation-alignment");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconRotationAlignment>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-rotation-alignment");
 }
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconSize() {
     return IconSize::defaultValue();
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconSize() const {
-    return impl->layout.unevaluated.get<IconSize>();
+    return impl().layout.unevaluated.get<IconSize>();
 }
 
 void SymbolLayer::setIconSize(DataDrivenPropertyValue<float> value) {
     if (value == getIconSize())
         return;
-    impl->layout.unevaluated.get<IconSize>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-size");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconSize>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-size");
 }
 PropertyValue<IconTextFitType> SymbolLayer::getDefaultIconTextFit() {
     return IconTextFit::defaultValue();
 }
 
 PropertyValue<IconTextFitType> SymbolLayer::getIconTextFit() const {
-    return impl->layout.unevaluated.get<IconTextFit>();
+    return impl().layout.unevaluated.get<IconTextFit>();
 }
 
 void SymbolLayer::setIconTextFit(PropertyValue<IconTextFitType> value) {
     if (value == getIconTextFit())
         return;
-    impl->layout.unevaluated.get<IconTextFit>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconTextFit>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit");
 }
 PropertyValue<std::array<float, 4>> SymbolLayer::getDefaultIconTextFitPadding() {
     return IconTextFitPadding::defaultValue();
 }
 
 PropertyValue<std::array<float, 4>> SymbolLayer::getIconTextFitPadding() const {
-    return impl->layout.unevaluated.get<IconTextFitPadding>();
+    return impl().layout.unevaluated.get<IconTextFitPadding>();
 }
 
 void SymbolLayer::setIconTextFitPadding(PropertyValue<std::array<float, 4>> value) {
     if (value == getIconTextFitPadding())
         return;
-    impl->layout.unevaluated.get<IconTextFitPadding>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit-padding");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconTextFitPadding>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit-padding");
 }
 DataDrivenPropertyValue<std::string> SymbolLayer::getDefaultIconImage() {
     return IconImage::defaultValue();
 }
 
 DataDrivenPropertyValue<std::string> SymbolLayer::getIconImage() const {
-    return impl->layout.unevaluated.get<IconImage>();
+    return impl().layout.unevaluated.get<IconImage>();
 }
 
 void SymbolLayer::setIconImage(DataDrivenPropertyValue<std::string> value) {
     if (value == getIconImage())
         return;
-    impl->layout.unevaluated.get<IconImage>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-image");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconImage>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-image");
 }
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconRotate() {
     return IconRotate::defaultValue();
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconRotate() const {
-    return impl->layout.unevaluated.get<IconRotate>();
+    return impl().layout.unevaluated.get<IconRotate>();
 }
 
 void SymbolLayer::setIconRotate(DataDrivenPropertyValue<float> value) {
     if (value == getIconRotate())
         return;
-    impl->layout.unevaluated.get<IconRotate>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-rotate");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconRotate>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-rotate");
 }
 PropertyValue<float> SymbolLayer::getDefaultIconPadding() {
     return IconPadding::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getIconPadding() const {
-    return impl->layout.unevaluated.get<IconPadding>();
+    return impl().layout.unevaluated.get<IconPadding>();
 }
 
 void SymbolLayer::setIconPadding(PropertyValue<float> value) {
     if (value == getIconPadding())
         return;
-    impl->layout.unevaluated.get<IconPadding>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-padding");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconPadding>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-padding");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconKeepUpright() {
     return IconKeepUpright::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconKeepUpright() const {
-    return impl->layout.unevaluated.get<IconKeepUpright>();
+    return impl().layout.unevaluated.get<IconKeepUpright>();
 }
 
 void SymbolLayer::setIconKeepUpright(PropertyValue<bool> value) {
     if (value == getIconKeepUpright())
         return;
-    impl->layout.unevaluated.get<IconKeepUpright>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-keep-upright");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconKeepUpright>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-keep-upright");
 }
 DataDrivenPropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconOffset() {
     return IconOffset::defaultValue();
 }
 
 DataDrivenPropertyValue<std::array<float, 2>> SymbolLayer::getIconOffset() const {
-    return impl->layout.unevaluated.get<IconOffset>();
+    return impl().layout.unevaluated.get<IconOffset>();
 }
 
 void SymbolLayer::setIconOffset(DataDrivenPropertyValue<std::array<float, 2>> value) {
     if (value == getIconOffset())
         return;
-    impl->layout.unevaluated.get<IconOffset>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "icon-offset");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<IconOffset>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "icon-offset");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultTextPitchAlignment() {
     return TextPitchAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getTextPitchAlignment() const {
-    return impl->layout.unevaluated.get<TextPitchAlignment>();
+    return impl().layout.unevaluated.get<TextPitchAlignment>();
 }
 
 void SymbolLayer::setTextPitchAlignment(PropertyValue<AlignmentType> value) {
     if (value == getTextPitchAlignment())
         return;
-    impl->layout.unevaluated.get<TextPitchAlignment>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-pitch-alignment");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextPitchAlignment>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-pitch-alignment");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultTextRotationAlignment() {
     return TextRotationAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getTextRotationAlignment() const {
-    return impl->layout.unevaluated.get<TextRotationAlignment>();
+    return impl().layout.unevaluated.get<TextRotationAlignment>();
 }
 
 void SymbolLayer::setTextRotationAlignment(PropertyValue<AlignmentType> value) {
     if (value == getTextRotationAlignment())
         return;
-    impl->layout.unevaluated.get<TextRotationAlignment>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-rotation-alignment");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextRotationAlignment>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-rotation-alignment");
 }
 DataDrivenPropertyValue<std::string> SymbolLayer::getDefaultTextField() {
     return TextField::defaultValue();
 }
 
 DataDrivenPropertyValue<std::string> SymbolLayer::getTextField() const {
-    return impl->layout.unevaluated.get<TextField>();
+    return impl().layout.unevaluated.get<TextField>();
 }
 
 void SymbolLayer::setTextField(DataDrivenPropertyValue<std::string> value) {
     if (value == getTextField())
         return;
-    impl->layout.unevaluated.get<TextField>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-field");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextField>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-field");
 }
 PropertyValue<std::vector<std::string>> SymbolLayer::getDefaultTextFont() {
     return TextFont::defaultValue();
 }
 
 PropertyValue<std::vector<std::string>> SymbolLayer::getTextFont() const {
-    return impl->layout.unevaluated.get<TextFont>();
+    return impl().layout.unevaluated.get<TextFont>();
 }
 
 void SymbolLayer::setTextFont(PropertyValue<std::vector<std::string>> value) {
     if (value == getTextFont())
         return;
-    impl->layout.unevaluated.get<TextFont>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-font");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextFont>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-font");
 }
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextSize() {
     return TextSize::defaultValue();
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextSize() const {
-    return impl->layout.unevaluated.get<TextSize>();
+    return impl().layout.unevaluated.get<TextSize>();
 }
 
 void SymbolLayer::setTextSize(DataDrivenPropertyValue<float> value) {
     if (value == getTextSize())
         return;
-    impl->layout.unevaluated.get<TextSize>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-size");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextSize>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-size");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextMaxWidth() {
     return TextMaxWidth::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextMaxWidth() const {
-    return impl->layout.unevaluated.get<TextMaxWidth>();
+    return impl().layout.unevaluated.get<TextMaxWidth>();
 }
 
 void SymbolLayer::setTextMaxWidth(PropertyValue<float> value) {
     if (value == getTextMaxWidth())
         return;
-    impl->layout.unevaluated.get<TextMaxWidth>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-max-width");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextMaxWidth>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-max-width");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextLineHeight() {
     return TextLineHeight::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextLineHeight() const {
-    return impl->layout.unevaluated.get<TextLineHeight>();
+    return impl().layout.unevaluated.get<TextLineHeight>();
 }
 
 void SymbolLayer::setTextLineHeight(PropertyValue<float> value) {
     if (value == getTextLineHeight())
         return;
-    impl->layout.unevaluated.get<TextLineHeight>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-line-height");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextLineHeight>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-line-height");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextLetterSpacing() {
     return TextLetterSpacing::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextLetterSpacing() const {
-    return impl->layout.unevaluated.get<TextLetterSpacing>();
+    return impl().layout.unevaluated.get<TextLetterSpacing>();
 }
 
 void SymbolLayer::setTextLetterSpacing(PropertyValue<float> value) {
     if (value == getTextLetterSpacing())
         return;
-    impl->layout.unevaluated.get<TextLetterSpacing>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-letter-spacing");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextLetterSpacing>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-letter-spacing");
 }
 PropertyValue<TextJustifyType> SymbolLayer::getDefaultTextJustify() {
     return TextJustify::defaultValue();
 }
 
 PropertyValue<TextJustifyType> SymbolLayer::getTextJustify() const {
-    return impl->layout.unevaluated.get<TextJustify>();
+    return impl().layout.unevaluated.get<TextJustify>();
 }
 
 void SymbolLayer::setTextJustify(PropertyValue<TextJustifyType> value) {
     if (value == getTextJustify())
         return;
-    impl->layout.unevaluated.get<TextJustify>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-justify");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextJustify>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-justify");
 }
 PropertyValue<TextAnchorType> SymbolLayer::getDefaultTextAnchor() {
     return TextAnchor::defaultValue();
 }
 
 PropertyValue<TextAnchorType> SymbolLayer::getTextAnchor() const {
-    return impl->layout.unevaluated.get<TextAnchor>();
+    return impl().layout.unevaluated.get<TextAnchor>();
 }
 
 void SymbolLayer::setTextAnchor(PropertyValue<TextAnchorType> value) {
     if (value == getTextAnchor())
         return;
-    impl->layout.unevaluated.get<TextAnchor>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-anchor");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextAnchor>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-anchor");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextMaxAngle() {
     return TextMaxAngle::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextMaxAngle() const {
-    return impl->layout.unevaluated.get<TextMaxAngle>();
+    return impl().layout.unevaluated.get<TextMaxAngle>();
 }
 
 void SymbolLayer::setTextMaxAngle(PropertyValue<float> value) {
     if (value == getTextMaxAngle())
         return;
-    impl->layout.unevaluated.get<TextMaxAngle>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-max-angle");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextMaxAngle>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-max-angle");
 }
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextRotate() {
     return TextRotate::defaultValue();
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextRotate() const {
-    return impl->layout.unevaluated.get<TextRotate>();
+    return impl().layout.unevaluated.get<TextRotate>();
 }
 
 void SymbolLayer::setTextRotate(DataDrivenPropertyValue<float> value) {
     if (value == getTextRotate())
         return;
-    impl->layout.unevaluated.get<TextRotate>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-rotate");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextRotate>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-rotate");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextPadding() {
     return TextPadding::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextPadding() const {
-    return impl->layout.unevaluated.get<TextPadding>();
+    return impl().layout.unevaluated.get<TextPadding>();
 }
 
 void SymbolLayer::setTextPadding(PropertyValue<float> value) {
     if (value == getTextPadding())
         return;
-    impl->layout.unevaluated.get<TextPadding>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-padding");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextPadding>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-padding");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextKeepUpright() {
     return TextKeepUpright::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextKeepUpright() const {
-    return impl->layout.unevaluated.get<TextKeepUpright>();
+    return impl().layout.unevaluated.get<TextKeepUpright>();
 }
 
 void SymbolLayer::setTextKeepUpright(PropertyValue<bool> value) {
     if (value == getTextKeepUpright())
         return;
-    impl->layout.unevaluated.get<TextKeepUpright>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-keep-upright");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextKeepUpright>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-keep-upright");
 }
 DataDrivenPropertyValue<TextTransformType> SymbolLayer::getDefaultTextTransform() {
     return TextTransform::defaultValue();
 }
 
 DataDrivenPropertyValue<TextTransformType> SymbolLayer::getTextTransform() const {
-    return impl->layout.unevaluated.get<TextTransform>();
+    return impl().layout.unevaluated.get<TextTransform>();
 }
 
 void SymbolLayer::setTextTransform(DataDrivenPropertyValue<TextTransformType> value) {
     if (value == getTextTransform())
         return;
-    impl->layout.unevaluated.get<TextTransform>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-transform");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextTransform>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-transform");
 }
 DataDrivenPropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextOffset() {
     return TextOffset::defaultValue();
 }
 
 DataDrivenPropertyValue<std::array<float, 2>> SymbolLayer::getTextOffset() const {
-    return impl->layout.unevaluated.get<TextOffset>();
+    return impl().layout.unevaluated.get<TextOffset>();
 }
 
 void SymbolLayer::setTextOffset(DataDrivenPropertyValue<std::array<float, 2>> value) {
     if (value == getTextOffset())
         return;
-    impl->layout.unevaluated.get<TextOffset>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-offset");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextOffset>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-offset");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextAllowOverlap() {
     return TextAllowOverlap::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextAllowOverlap() const {
-    return impl->layout.unevaluated.get<TextAllowOverlap>();
+    return impl().layout.unevaluated.get<TextAllowOverlap>();
 }
 
 void SymbolLayer::setTextAllowOverlap(PropertyValue<bool> value) {
     if (value == getTextAllowOverlap())
         return;
-    impl->layout.unevaluated.get<TextAllowOverlap>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-allow-overlap");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextAllowOverlap>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-allow-overlap");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextIgnorePlacement() {
     return TextIgnorePlacement::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextIgnorePlacement() const {
-    return impl->layout.unevaluated.get<TextIgnorePlacement>();
+    return impl().layout.unevaluated.get<TextIgnorePlacement>();
 }
 
 void SymbolLayer::setTextIgnorePlacement(PropertyValue<bool> value) {
     if (value == getTextIgnorePlacement())
         return;
-    impl->layout.unevaluated.get<TextIgnorePlacement>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-ignore-placement");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextIgnorePlacement>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-ignore-placement");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextOptional() {
     return TextOptional::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextOptional() const {
-    return impl->layout.unevaluated.get<TextOptional>();
+    return impl().layout.unevaluated.get<TextOptional>();
 }
 
 void SymbolLayer::setTextOptional(PropertyValue<bool> value) {
     if (value == getTextOptional())
         return;
-    impl->layout.unevaluated.get<TextOptional>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "text-optional");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<TextOptional>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "text-optional");
 }
 
 // Paint properties
@@ -547,26 +645,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconOpacity() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconOpacity>().get(klass);
+    return impl().cascading.template get<IconOpacity>().get(klass);
 }
 
 void SymbolLayer::setIconOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconOpacity(klass))
         return;
-    impl->cascading.template get<IconOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setIconOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconOpacity>().getTransition(klass);
+    return impl().cascading.template get<IconOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() {
@@ -574,26 +676,30 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getIconColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconColor>().get(klass);
+    return impl().cascading.template get<IconColor>().get(klass);
 }
 
 void SymbolLayer::setIconColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconColor(klass))
         return;
-    impl->cascading.template get<IconColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setIconColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconColor>().getTransition(klass);
+    return impl().cascading.template get<IconColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
@@ -601,26 +707,30 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getIconHaloColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloColor>().get(klass);
+    return impl().cascading.template get<IconHaloColor>().get(klass);
 }
 
 void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconHaloColor(klass))
         return;
-    impl->cascading.template get<IconHaloColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setIconHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconHaloColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconHaloColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloColor>().getTransition(klass);
+    return impl().cascading.template get<IconHaloColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
@@ -628,26 +738,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconHaloWidth(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloWidth>().get(klass);
+    return impl().cascading.template get<IconHaloWidth>().get(klass);
 }
 
 void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloWidth(klass))
         return;
-    impl->cascading.template get<IconHaloWidth>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloWidth>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setIconHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconHaloWidth>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloWidth>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconHaloWidthTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloWidth>().getTransition(klass);
+    return impl().cascading.template get<IconHaloWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
@@ -655,26 +769,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconHaloBlur(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloBlur>().get(klass);
+    return impl().cascading.template get<IconHaloBlur>().get(klass);
 }
 
 void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloBlur(klass))
         return;
-    impl->cascading.template get<IconHaloBlur>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloBlur>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setIconHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconHaloBlur>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconHaloBlur>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconHaloBlurTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconHaloBlur>().getTransition(klass);
+    return impl().cascading.template get<IconHaloBlur>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
@@ -682,22 +800,26 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconTranslate>().get(klass);
+    return impl().cascading.template get<IconTranslate>().get(klass);
 }
 
 void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getIconTranslate(klass))
         return;
-    impl->cascading.template get<IconTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setIconTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconTranslate>().getTransition(klass);
+    return impl().cascading.template get<IconTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor() {
@@ -705,22 +827,26 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor()
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconTranslateAnchor>().get(klass);
+    return impl().cascading.template get<IconTranslateAnchor>().get(klass);
 }
 
 void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getIconTranslateAnchor(klass))
         return;
-    impl->cascading.template get<IconTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setIconTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<IconTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<IconTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getIconTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<IconTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<IconTranslateAnchor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
@@ -728,26 +854,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextOpacity(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextOpacity>().get(klass);
+    return impl().cascading.template get<TextOpacity>().get(klass);
 }
 
 void SymbolLayer::setTextOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextOpacity(klass))
         return;
-    impl->cascading.template get<TextOpacity>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextOpacity>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setTextOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextOpacity>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextOpacity>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextOpacityTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextOpacity>().getTransition(klass);
+    return impl().cascading.template get<TextOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() {
@@ -755,26 +885,30 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getTextColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextColor>().get(klass);
+    return impl().cascading.template get<TextColor>().get(klass);
 }
 
 void SymbolLayer::setTextColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextColor(klass))
         return;
-    impl->cascading.template get<TextColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setTextColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextColor>().getTransition(klass);
+    return impl().cascading.template get<TextColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
@@ -782,26 +916,30 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getTextHaloColor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloColor>().get(klass);
+    return impl().cascading.template get<TextHaloColor>().get(klass);
 }
 
 void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextHaloColor(klass))
         return;
-    impl->cascading.template get<TextHaloColor>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloColor>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setTextHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextHaloColor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloColor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextHaloColorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloColor>().getTransition(klass);
+    return impl().cascading.template get<TextHaloColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
@@ -809,26 +947,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextHaloWidth(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloWidth>().get(klass);
+    return impl().cascading.template get<TextHaloWidth>().get(klass);
 }
 
 void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloWidth(klass))
         return;
-    impl->cascading.template get<TextHaloWidth>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloWidth>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setTextHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextHaloWidth>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloWidth>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextHaloWidthTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloWidth>().getTransition(klass);
+    return impl().cascading.template get<TextHaloWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
@@ -836,26 +978,30 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextHaloBlur(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloBlur>().get(klass);
+    return impl().cascading.template get<TextHaloBlur>().get(klass);
 }
 
 void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloBlur(klass))
         return;
-    impl->cascading.template get<TextHaloBlur>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloBlur>().set(value, klass);
+    baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 }
 
 void SymbolLayer::setTextHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextHaloBlur>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextHaloBlur>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextHaloBlurTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextHaloBlur>().getTransition(klass);
+    return impl().cascading.template get<TextHaloBlur>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
@@ -863,22 +1009,26 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextTranslate>().get(klass);
+    return impl().cascading.template get<TextTranslate>().get(klass);
 }
 
 void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getTextTranslate(klass))
         return;
-    impl->cascading.template get<TextTranslate>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextTranslate>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setTextTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextTranslate>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextTranslate>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextTranslateTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextTranslate>().getTransition(klass);
+    return impl().cascading.template get<TextTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor() {
@@ -886,22 +1036,26 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor()
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextTranslateAnchor>().get(klass);
+    return impl().cascading.template get<TextTranslateAnchor>().get(klass);
 }
 
 void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getTextTranslateAnchor(klass))
         return;
-    impl->cascading.template get<TextTranslateAnchor>().set(value, klass);
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextTranslateAnchor>().set(value, klass);
+    baseImpl = std::move(impl_);
+    observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setTextTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<TextTranslateAnchor>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<TextTranslateAnchor>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions SymbolLayer::getTextTranslateAnchorTransition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<TextTranslateAnchor>().getTransition(klass);
+    return impl().cascading.template get<TextTranslateAnchor>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp
index c99dd8ad70..220a17fd36 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.cpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 
 std::unique_ptr<RenderLayer> SymbolLayer::Impl::createRenderLayer() const {
-    return std::make_unique<RenderSymbolLayer>(*this);
+    return std::make_unique<RenderSymbolLayer>(staticImmutableCast<SymbolLayer::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp
index df145647a0..4937ee8721 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.hpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.hpp
@@ -6,13 +6,12 @@
 #include <mbgl/style/layers/symbol_layer_properties.hpp>
 
 namespace mbgl {
-
 namespace style {
 
 class SymbolLayer::Impl : public Layer::Impl {
 public:
-    std::unique_ptr<Layer> clone() const override;
-    std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
+    using Layer::Impl::Impl;
+
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     std::unique_ptr<RenderLayer> createRenderLayer() const override;
diff --git a/src/mbgl/style/light.cpp b/src/mbgl/style/light.cpp
index b54920713c..d2f91c73af 100644
--- a/src/mbgl/style/light.cpp
+++ b/src/mbgl/style/light.cpp
@@ -2,17 +2,29 @@
 
 #include <mbgl/style/light.hpp>
 #include <mbgl/style/light_impl.hpp>
+#include <mbgl/style/light_observer.hpp>
 #include <mbgl/style/light_properties.hpp>
 
 namespace mbgl {
 namespace style {
 
+static LightObserver nullObserver;
+
 Light::Light()
-        : impl(std::make_unique<Impl>()) {
+    : impl(makeMutable<Impl>()),
+      observer(&nullObserver) {
 }
 
 Light::~Light() = default;
 
+void Light::setObserver(LightObserver* observer_) {
+    observer = observer_ ? observer_ : &nullObserver;
+}
+
+Mutable<Light::Impl> Light::mutableImpl() const {
+    return makeMutable<Impl>(*impl);
+}
+
 LightAnchorType Light::getDefaultAnchor() {
     return LightAnchor::defaultValue();
 }
@@ -22,13 +34,17 @@ PropertyValue<LightAnchorType> Light::getAnchor() const {
 }
 
 void Light::setAnchor(PropertyValue<LightAnchorType> property) {
-    impl->properties.template get<LightAnchor>().value = property;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightAnchor>().value = property;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 void Light::setAnchorTransition(const TransitionOptions& transition) {
-    impl->properties.template get<LightAnchor>().transition = transition;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightAnchor>().transition = transition;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 TransitionOptions Light::getAnchorTransition() const {
@@ -44,13 +60,17 @@ PropertyValue<Position> Light::getPosition() const {
 }
 
 void Light::setPosition(PropertyValue<Position> property) {
-    impl->properties.template get<LightPosition>().value = property;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightPosition>().value = property;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 void Light::setPositionTransition(const TransitionOptions& transition) {
-    impl->properties.template get<LightPosition>().transition = transition;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightPosition>().transition = transition;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 TransitionOptions Light::getPositionTransition() const {
@@ -66,13 +86,17 @@ PropertyValue<Color> Light::getColor() const {
 }
 
 void Light::setColor(PropertyValue<Color> property) {
-    impl->properties.template get<LightColor>().value = property;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightColor>().value = property;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 void Light::setColorTransition(const TransitionOptions& transition) {
-    impl->properties.template get<LightColor>().transition = transition;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightColor>().transition = transition;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 TransitionOptions Light::getColorTransition() const {
@@ -88,13 +112,17 @@ PropertyValue<float> Light::getIntensity() const {
 }
 
 void Light::setIntensity(PropertyValue<float> property) {
-    impl->properties.template get<LightIntensity>().value = property;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightIntensity>().value = property;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 void Light::setIntensityTransition(const TransitionOptions& transition) {
-    impl->properties.template get<LightIntensity>().transition = transition;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<LightIntensity>().transition = transition;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 TransitionOptions Light::getIntensityTransition() const {
diff --git a/src/mbgl/style/light.cpp.ejs b/src/mbgl/style/light.cpp.ejs
index c82c65c10c..454bad49d8 100644
--- a/src/mbgl/style/light.cpp.ejs
+++ b/src/mbgl/style/light.cpp.ejs
@@ -5,17 +5,29 @@
 
 #include <mbgl/style/light.hpp>
 #include <mbgl/style/light_impl.hpp>
+#include <mbgl/style/light_observer.hpp>
 #include <mbgl/style/light_properties.hpp>
 
 namespace mbgl {
 namespace style {
 
+static LightObserver nullObserver;
+
 Light::Light()
-        : impl(std::make_unique<Impl>()) {
+    : impl(makeMutable<Impl>()),
+      observer(&nullObserver) {
 }
 
 Light::~Light() = default;
 
+void Light::setObserver(LightObserver* observer_) {
+    observer = observer_ ? observer_ : &nullObserver;
+}
+
+Mutable<Light::Impl> Light::mutableImpl() const {
+    return makeMutable<Impl>(*impl);
+}
+
 <% for (const property of properties) { -%>
 <%- evaluatedType(property) %> Light::getDefault<%- camelize(property.name) %>() {
     return Light<%- camelize(property.name) %>::defaultValue();
@@ -26,13 +38,17 @@ Light::~Light() = default;
 }
 
 void Light::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> property) {
-    impl->properties.template get<Light<%- camelize(property.name) %>>().value = property;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<Light<%- camelize(property.name) %>>().value = property;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 void Light::set<%- camelize(property.name) %>Transition(const TransitionOptions& transition) {
-    impl->properties.template get<Light<%- camelize(property.name) %>>().transition = transition;
-    impl->observer->onLightChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->properties.template get<Light<%- camelize(property.name) %>>().transition = transition;
+    impl = std::move(impl_);
+    observer->onLightChanged(*this);
 }
 
 TransitionOptions Light::get<%- camelize(property.name) %>Transition() const {
diff --git a/src/mbgl/style/light_impl.cpp b/src/mbgl/style/light_impl.cpp
index e0ab1176ed..619d115f02 100644
--- a/src/mbgl/style/light_impl.cpp
+++ b/src/mbgl/style/light_impl.cpp
@@ -3,9 +3,5 @@
 namespace mbgl {
 namespace style {
 
-void Light::Impl::setObserver(LightObserver* observer_) {
-    observer = observer_;
-}
-
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/light_impl.hpp b/src/mbgl/style/light_impl.hpp
index b4fd886742..d607cf00e5 100644
--- a/src/mbgl/style/light_impl.hpp
+++ b/src/mbgl/style/light_impl.hpp
@@ -1,18 +1,13 @@
 #pragma once
 
+#include <mbgl/style/light.hpp>
 #include <mbgl/style/light_properties.hpp>
-#include <mbgl/style/light_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 class Light::Impl {
 public:
-
-    LightObserver nullObserver;
-    LightObserver* observer = &nullObserver;
-    void setObserver(LightObserver*);
-
     IndexedTuple<LightProperties, LightProperties> properties;
 };
 
diff --git a/src/mbgl/style/light_observer.hpp b/src/mbgl/style/light_observer.hpp
index 751a84850d..45beb64928 100644
--- a/src/mbgl/style/light_observer.hpp
+++ b/src/mbgl/style/light_observer.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <mbgl/style/light.hpp>
-
 namespace mbgl {
 namespace style {
 
+class Light;
+
 class LightObserver {
 public:
     virtual ~LightObserver() = default;
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index fc3ccf410b..ea96bda502 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -236,7 +236,7 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
             return;
         }
 
-        layer = reference->baseImpl->cloneRef(id);
+        layer = reference->cloneRef(id);
         conversion::setPaintProperties(*layer, value);
     } else {
         conversion::Error error;
diff --git a/src/mbgl/style/source.cpp b/src/mbgl/style/source.cpp
index cfb268006b..4fcebc8377 100644
--- a/src/mbgl/style/source.cpp
+++ b/src/mbgl/style/source.cpp
@@ -1,15 +1,24 @@
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/source_observer.hpp>
+#include <mbgl/util/logging.hpp>
 
 namespace mbgl {
 namespace style {
 
-Source::Source(SourceType type_, std::unique_ptr<Impl> baseImpl_)
-    : baseImpl(std::move(baseImpl_)), type(type_) {
+static SourceObserver nullObserver;
+
+Source::Source(Immutable<Impl> impl)
+    : baseImpl(std::move(impl)),
+      observer(&nullObserver) {
 }
 
 Source::~Source() = default;
 
+SourceType Source::getType() const {
+    return baseImpl->type;
+}
+
 const std::string& Source::getID() const {
     return baseImpl->id;
 }
@@ -18,5 +27,14 @@ optional<std::string> Source::getAttribution() const {
     return baseImpl->getAttribution();
 }
 
+void Source::setObserver(SourceObserver* observer_) {
+    observer = observer_ ? observer_ : &nullObserver;
+}
+
+void Source::dumpDebugLogs() const {
+    Log::Info(Event::General, "Source::id: %s", getID().c_str());
+    Log::Info(Event::General, "Source::loaded: %d", loaded);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/source_impl.cpp b/src/mbgl/style/source_impl.cpp
index 1e9405abbb..0683f847cb 100644
--- a/src/mbgl/style/source_impl.cpp
+++ b/src/mbgl/style/source_impl.cpp
@@ -1,26 +1,11 @@
 #include <mbgl/style/source_impl.hpp>
-#include <mbgl/style/source_observer.hpp>
-#include <mbgl/util/logging.hpp>
 
 namespace mbgl {
 namespace style {
 
-static SourceObserver nullObserver;
-
-Source::Impl::Impl(SourceType type_, std::string id_, Source& base_)
+Source::Impl::Impl(SourceType type_, std::string id_)
     : type(type_),
-      id(std::move(id_)),
-      base(base_),
-      observer(&nullObserver) {
-}
-
-void Source::Impl::dumpDebugLogs() const {
-    Log::Info(Event::General, "Source::id: %s", base.getID().c_str());
-    Log::Info(Event::General, "Source::loaded: %d", loaded);
-}
-
-void Source::Impl::setObserver(SourceObserver* observer_) {
-    observer = observer_ ? observer_ : &nullObserver;
+      id(std::move(id_)) {
 }
 
 } // namespace style
diff --git a/src/mbgl/style/source_impl.hpp b/src/mbgl/style/source_impl.hpp
index 2514ec5120..3620ec4e50 100644
--- a/src/mbgl/style/source_impl.hpp
+++ b/src/mbgl/style/source_impl.hpp
@@ -3,35 +3,30 @@
 #include <mbgl/style/source.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
+#include <string>
+
 namespace mbgl {
 
-class FileSource;
 class RenderSource;
 
 namespace style {
 
 class SourceObserver;
 
-class Source::Impl : private util::noncopyable {
+class Source::Impl : public EnableImmutableFromThis<Source::Impl> {
 public:
-    Impl(SourceType, std::string id, Source&);
     virtual ~Impl() = default;
 
-    virtual void loadDescription(FileSource&) = 0;
+    virtual optional<std::string> getAttribution() const = 0;
     virtual std::unique_ptr<RenderSource> createRenderSource() const = 0;
 
-    virtual optional<std::string> getAttribution() const { return {}; };
-
     const SourceType type;
     const std::string id;
 
-    bool loaded = false;
-    Source& base;
-
-    void setObserver(SourceObserver*);
-    SourceObserver* observer = nullptr;
-
-    void dumpDebugLogs() const;
+protected:
+    Impl(SourceType, std::string);
+    Impl(const Impl&) = default;
+    Impl& operator=(const Impl&) = delete;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp
index 110c1cd63c..d04c8ffce4 100644
--- a/src/mbgl/style/sources/geojson_source.cpp
+++ b/src/mbgl/style/sources/geojson_source.cpp
@@ -1,25 +1,80 @@
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/style/sources/geojson_source_impl.hpp>
+#include <mbgl/style/source_observer.hpp>
+#include <mbgl/style/conversion/json.hpp>
+#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/util/logging.hpp>
 
 namespace mbgl {
 namespace style {
 
 GeoJSONSource::GeoJSONSource(const std::string& id, const GeoJSONOptions& options)
-    : Source(SourceType::GeoJSON,
-             std::make_unique<GeoJSONSource::Impl>(std::move(id), *this, options)),
-      impl(static_cast<Impl*>(baseImpl.get())) {
+    : Source(makeMutable<Impl>(std::move(id), options)) {
 }
 
-void GeoJSONSource::setURL(const std::string& url) {
-    impl->setURL(url);
+GeoJSONSource::~GeoJSONSource() = default;
+
+const GeoJSONSource::Impl& GeoJSONSource::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
+}
+
+void GeoJSONSource::setURL(const std::string& url_) {
+    url = std::move(url_);
+
+    // Signal that the source description needs a reload
+    if (loaded || req) {
+        loaded = false;
+        req.reset();
+        observer->onSourceDescriptionChanged(*this);
+    }
 }
 
 void GeoJSONSource::setGeoJSON(const mapbox::geojson::geojson& geoJSON) {
-    impl->setGeoJSON(geoJSON);
+    req.reset();
+    baseImpl = makeMutable<Impl>(impl(), geoJSON);
 }
 
 optional<std::string> GeoJSONSource::getURL() const {
-    return impl->getURL();
+    return url;
+}
+
+void GeoJSONSource::loadDescription(FileSource& fileSource) {
+    if (!url) {
+        loaded = true;
+        return;
+    }
+
+    if (req) {
+        return;
+    }
+
+    req = fileSource.request(Resource::source(*url), [this](Response res) {
+        if (res.error) {
+            observer->onSourceError(
+                *this, std::make_exception_ptr(std::runtime_error(res.error->message)));
+        } else if (res.notModified) {
+            return;
+        } else if (res.noContent) {
+            observer->onSourceError(
+                *this, std::make_exception_ptr(std::runtime_error("unexpectedly empty GeoJSON")));
+        } else {
+            conversion::Error error;
+            optional<GeoJSON> geoJSON = conversion::convertJSON<GeoJSON>(*res.data, error);
+            if (!geoJSON) {
+                Log::Error(Event::ParseStyle, "Failed to parse GeoJSON data: %s",
+                           error.message.c_str());
+                // Create an empty GeoJSON VT object to make sure we're not infinitely waiting for
+                // tiles to load.
+                baseImpl = makeMutable<Impl>(impl(), GeoJSON{ FeatureCollection{} });
+            } else {
+                baseImpl = makeMutable<Impl>(impl(), *geoJSON);
+            }
+
+            loaded = true;
+            observer->onSourceLoaded(*this);
+        }
+    });
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/geojson_source_impl.cpp b/src/mbgl/style/sources/geojson_source_impl.cpp
index 1a686ff9bc..17d05aaa5a 100644
--- a/src/mbgl/style/sources/geojson_source_impl.cpp
+++ b/src/mbgl/style/sources/geojson_source_impl.cpp
@@ -1,12 +1,6 @@
 #include <mbgl/style/sources/geojson_source_impl.hpp>
-#include <mbgl/style/conversion/json.hpp>
-#include <mbgl/style/conversion/geojson.hpp>
-#include <mbgl/style/source_observer.hpp>
-#include <mbgl/tile/tile_id.hpp>
-#include <mbgl/storage/file_source.hpp>
 #include <mbgl/renderer/sources/render_geojson_source.hpp>
 #include <mbgl/util/constants.cpp>
-#include <mbgl/util/logging.hpp>
 
 #include <mapbox/geojsonvt.hpp>
 #include <supercluster.hpp>
@@ -42,33 +36,14 @@ private:
     mapbox::supercluster::Supercluster impl;
 };
 
-GeoJSONSource::Impl::Impl(std::string id_, Source& base_, const GeoJSONOptions options_)
-    : Source::Impl(SourceType::GeoJSON, std::move(id_), base_), options(options_) {
+GeoJSONSource::Impl::Impl(std::string id_, GeoJSONOptions options_)
+    : Source::Impl(SourceType::GeoJSON, std::move(id_)),
+      options(std::move(options_)) {
 }
 
-GeoJSONSource::Impl::~Impl() = default;
-
-void GeoJSONSource::Impl::setURL(std::string url_) {
-    url = std::move(url_);
-
-    // Signal that the source description needs a reload
-    if (loaded || req) {
-        loaded = false;
-        req.reset();
-        observer->onSourceDescriptionChanged(base);
-    }
-}
-
-optional<std::string> GeoJSONSource::Impl::getURL() const {
-    return url;
-}
-
-void GeoJSONSource::Impl::setGeoJSON(const GeoJSON& geoJSON) {
-    req.reset();
-    _setGeoJSON(geoJSON);
-}
-
-void GeoJSONSource::Impl::_setGeoJSON(const GeoJSON& geoJSON) {
+GeoJSONSource::Impl::Impl(const Impl& other, const GeoJSON& geoJSON)
+    : Source::Impl(other),
+      options(other.options) {
     double scale = util::EXTENT / util::tileSize;
 
     if (options.cluster
@@ -90,47 +65,7 @@ void GeoJSONSource::Impl::_setGeoJSON(const GeoJSON& geoJSON) {
     }
 }
 
-void GeoJSONSource::Impl::loadDescription(FileSource& fileSource) {
-    if (!url) {
-        loaded = true;
-        return;
-    }
-
-    if (req) {
-        return;
-    }
-
-    req = fileSource.request(Resource::source(*url), [this](Response res) {
-        if (res.error) {
-            observer->onSourceError(
-                base, std::make_exception_ptr(std::runtime_error(res.error->message)));
-        } else if (res.notModified) {
-            return;
-        } else if (res.noContent) {
-            observer->onSourceError(
-                base, std::make_exception_ptr(std::runtime_error("unexpectedly empty GeoJSON")));
-        } else {
-            conversion::Error error;
-            optional<GeoJSON> geoJSON = conversion::convertJSON<GeoJSON>(*res.data, error);
-            if (!geoJSON) {
-                Log::Error(Event::ParseStyle, "Failed to parse GeoJSON data: %s",
-                           error.message.c_str());
-                // Create an empty GeoJSON VT object to make sure we're not infinitely waiting for
-                // tiles to load.
-                _setGeoJSON(GeoJSON{ FeatureCollection{} });
-            } else {
-                _setGeoJSON(*geoJSON);
-            }
-
-            loaded = true;
-            observer->onSourceLoaded(base);
-        }
-    });
-}
-
-std::unique_ptr<RenderSource> GeoJSONSource::Impl::createRenderSource() const {
-    return std::make_unique<RenderGeoJSONSource>(*this);
-}
+GeoJSONSource::Impl::~Impl() = default;
 
 Range<uint8_t> GeoJSONSource::Impl::getZoomRange() const {
     return { 0, options.maxzoom };
@@ -140,5 +75,13 @@ GeoJSONData* GeoJSONSource::Impl::getData() const {
     return data.get();
 }
 
+optional<std::string> GeoJSONSource::Impl::getAttribution() const {
+    return {};
+}
+
+std::unique_ptr<RenderSource> GeoJSONSource::Impl::createRenderSource() const {
+    return std::make_unique<RenderGeoJSONSource>(staticImmutableCast<GeoJSONSource::Impl>(immutableFromThis()));
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/sources/geojson_source_impl.hpp b/src/mbgl/style/sources/geojson_source_impl.hpp
index e8b881d05e..65580700e7 100644
--- a/src/mbgl/style/sources/geojson_source_impl.hpp
+++ b/src/mbgl/style/sources/geojson_source_impl.hpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/sources/geojson_source.hpp>
-#include <mbgl/util/variant.hpp>
+#include <mbgl/util/range.hpp>
 
 namespace mbgl {
 
@@ -18,25 +18,18 @@ public:
 
 class GeoJSONSource::Impl : public Source::Impl {
 public:
-    Impl(std::string id, Source&, const GeoJSONOptions);
+    Impl(std::string id, GeoJSONOptions);
+    Impl(const GeoJSONSource::Impl&, const GeoJSON&);
     ~Impl() final;
 
-    void setURL(std::string);
-    optional<std::string> getURL() const;
     Range<uint8_t> getZoomRange() const;
-
-    void setGeoJSON(const GeoJSON&);
     GeoJSONData* getData() const;
 
-    void loadDescription(FileSource&) final;
+    optional<std::string> getAttribution() const final;
     std::unique_ptr<RenderSource> createRenderSource() const final;
 
 private:
-    void _setGeoJSON(const GeoJSON&);
-
     GeoJSONOptions options;
-    optional<std::string> url;
-    std::unique_ptr<AsyncRequest> req;
     std::unique_ptr<GeoJSONData> data;
 };
 
diff --git a/src/mbgl/style/sources/raster_source.cpp b/src/mbgl/style/sources/raster_source.cpp
index 94fdbcef12..0a0412a4ed 100644
--- a/src/mbgl/style/sources/raster_source.cpp
+++ b/src/mbgl/style/sources/raster_source.cpp
@@ -1,21 +1,81 @@
 #include <mbgl/style/sources/raster_source.hpp>
 #include <mbgl/style/sources/raster_source_impl.hpp>
+#include <mbgl/style/source_observer.hpp>
+#include <mbgl/style/conversion/json.hpp>
+#include <mbgl/style/conversion/tileset.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/util/mapbox.hpp>
 
 namespace mbgl {
 namespace style {
 
-RasterSource::RasterSource(std::string id, variant<std::string, Tileset> urlOrTileset, uint16_t tileSize)
-    : Source(SourceType::Raster, std::make_unique<RasterSource::Impl>(std::move(id), *this, std::move(urlOrTileset), tileSize)),
-      impl(static_cast<Impl*>(baseImpl.get())) {
+RasterSource::RasterSource(std::string id, variant<std::string, Tileset> urlOrTileset_, uint16_t tileSize)
+    : Source(makeMutable<Impl>(std::move(id), tileSize)),
+      urlOrTileset(std::move(urlOrTileset_)) {
+}
+
+RasterSource::~RasterSource() = default;
+
+const RasterSource::Impl& RasterSource::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
+}
+
+const variant<std::string, Tileset>& RasterSource::getURLOrTileset() const {
+    return urlOrTileset;
 }
 
 optional<std::string> RasterSource::getURL() const {
-    auto urlOrTileset = impl->getURLOrTileset();
-    if (urlOrTileset.is<std::string>()) {
-        return urlOrTileset.get<std::string>();
-    } else {
+    if (urlOrTileset.is<Tileset>()) {
         return {};
     }
+
+    return urlOrTileset.get<std::string>();
+}
+
+uint16_t RasterSource::getTileSize() const {
+    return impl().getTileSize();
+}
+
+void RasterSource::loadDescription(FileSource& fileSource) {
+    if (urlOrTileset.is<Tileset>()) {
+        baseImpl = makeMutable<Impl>(impl(), urlOrTileset.get<Tileset>());
+        loaded = true;
+        return;
+    }
+
+    if (req) {
+        return;
+    }
+
+    const std::string& url = urlOrTileset.get<std::string>();
+    req = fileSource.request(Resource::source(url), [this, url](Response res) {
+        if (res.error) {
+            observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
+        } else if (res.notModified) {
+            return;
+        } else if (res.noContent) {
+            observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error("unexpectedly empty TileJSON")));
+        } else {
+            conversion::Error error;
+            optional<Tileset> tileset = conversion::convertJSON<Tileset>(*res.data, error);
+            if (!tileset) {
+                observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(error.message)));
+                return;
+            }
+
+            util::mapbox::canonicalizeTileset(*tileset, url, getType(), getTileSize());
+            bool changed = impl().getTileset() != *tileset;
+
+            baseImpl = makeMutable<Impl>(impl(), *tileset);
+            loaded = true;
+
+            observer->onSourceLoaded(*this);
+
+            if (changed) {
+                observer->onSourceChanged(*this);
+            }
+        }
+    });
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/raster_source_impl.cpp b/src/mbgl/style/sources/raster_source_impl.cpp
index b85d221f2e..1d684524c7 100644
--- a/src/mbgl/style/sources/raster_source_impl.cpp
+++ b/src/mbgl/style/sources/raster_source_impl.cpp
@@ -4,14 +4,34 @@
 namespace mbgl {
 namespace style {
 
-RasterSource::Impl::Impl(std::string id_, Source& base_,
-                         variant<std::string, Tileset> urlOrTileset_,
-                         uint16_t tileSize_)
-    : TileSourceImpl(SourceType::Raster, std::move(id_), base_, std::move(urlOrTileset_), tileSize_) {
+RasterSource::Impl::Impl(std::string id_, uint16_t tileSize_)
+    : Source::Impl(SourceType::Raster, std::move(id_)),
+      tileSize(tileSize_) {
+}
+
+RasterSource::Impl::Impl(const Impl& other, Tileset tileset_)
+    : Source::Impl(other),
+      tileSize(other.tileSize),
+      tileset(std::move(tileset_)) {
+}
+
+uint16_t RasterSource::Impl::getTileSize() const {
+    return tileSize;
+}
+
+optional<Tileset> RasterSource::Impl::getTileset() const {
+    return tileset;
+}
+
+optional<std::string> RasterSource::Impl::getAttribution() const {
+    if (!tileset) {
+        return {};
+    }
+    return tileset->attribution;
 }
 
 std::unique_ptr<RenderSource> RasterSource::Impl::createRenderSource() const {
-    return std::make_unique<RenderRasterSource>(*this);
+    return std::make_unique<RenderRasterSource>(staticImmutableCast<RasterSource::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/raster_source_impl.hpp b/src/mbgl/style/sources/raster_source_impl.hpp
index 4bc76560f8..0a58953ab7 100644
--- a/src/mbgl/style/sources/raster_source_impl.hpp
+++ b/src/mbgl/style/sources/raster_source_impl.hpp
@@ -1,16 +1,25 @@
 #pragma once
 
 #include <mbgl/style/sources/raster_source.hpp>
-#include <mbgl/style/tile_source_impl.hpp>
+#include <mbgl/style/source_impl.hpp>
 
 namespace mbgl {
 namespace style {
 
-class RasterSource::Impl : public TileSourceImpl {
+class RasterSource::Impl : public Source::Impl {
 public:
-    Impl(std::string id, Source&, variant<std::string, Tileset>, uint16_t tileSize);
+    Impl(std::string id, uint16_t tileSize);
+    Impl(const Impl&, Tileset);
 
+    optional<Tileset> getTileset() const;
+    uint16_t getTileSize() const;
+
+    optional<std::string> getAttribution() const final;
     std::unique_ptr<RenderSource> createRenderSource() const final;
+
+private:
+    uint16_t tileSize;
+    optional<Tileset> tileset;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/sources/vector_source.cpp b/src/mbgl/style/sources/vector_source.cpp
index 4bcd3b8985..ccdd453c75 100644
--- a/src/mbgl/style/sources/vector_source.cpp
+++ b/src/mbgl/style/sources/vector_source.cpp
@@ -1,21 +1,78 @@
 #include <mbgl/style/sources/vector_source.hpp>
 #include <mbgl/style/sources/vector_source_impl.hpp>
+#include <mbgl/style/source_observer.hpp>
+#include <mbgl/style/conversion/json.hpp>
+#include <mbgl/style/conversion/tileset.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/util/mapbox.hpp>
+#include <mbgl/util/constants.hpp>
 
 namespace mbgl {
 namespace style {
 
-VectorSource::VectorSource(std::string id, variant<std::string, Tileset> urlOrTileset)
-    : Source(SourceType::Vector, std::make_unique<VectorSource::Impl>(std::move(id), *this, std::move(urlOrTileset))),
-      impl(static_cast<Impl*>(baseImpl.get())) {
+VectorSource::VectorSource(std::string id, variant<std::string, Tileset> urlOrTileset_)
+    : Source(makeMutable<Impl>(std::move(id))),
+      urlOrTileset(std::move(urlOrTileset_)) {
+}
+
+VectorSource::~VectorSource() = default;
+
+const VectorSource::Impl& VectorSource::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
+}
+
+const variant<std::string, Tileset>& VectorSource::getURLOrTileset() const {
+    return urlOrTileset;
 }
 
 optional<std::string> VectorSource::getURL() const {
-    auto urlOrTileset = impl->getURLOrTileset();
-    if (urlOrTileset.is<std::string>()) {
-        return urlOrTileset.get<std::string>();
-    } else {
+    if (urlOrTileset.is<Tileset>()) {
         return {};
     }
+
+    return urlOrTileset.get<std::string>();
+}
+
+void VectorSource::loadDescription(FileSource& fileSource) {
+    if (urlOrTileset.is<Tileset>()) {
+        baseImpl = makeMutable<Impl>(impl(), urlOrTileset.get<Tileset>());
+        loaded = true;
+        return;
+    }
+
+    if (req) {
+        return;
+    }
+
+    const std::string& url = urlOrTileset.get<std::string>();
+    req = fileSource.request(Resource::source(url), [this, url](Response res) {
+        if (res.error) {
+            observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
+        } else if (res.notModified) {
+            return;
+        } else if (res.noContent) {
+            observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error("unexpectedly empty TileJSON")));
+        } else {
+            conversion::Error error;
+            optional<Tileset> tileset = conversion::convertJSON<Tileset>(*res.data, error);
+            if (!tileset) {
+                observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(error.message)));
+                return;
+            }
+
+            util::mapbox::canonicalizeTileset(*tileset, url, getType(), util::tileSize);
+            bool changed = impl().getTileset() != *tileset;
+
+            baseImpl = makeMutable<Impl>(impl(), *tileset);
+            loaded = true;
+
+            observer->onSourceLoaded(*this);
+
+            if (changed) {
+                observer->onSourceChanged(*this);
+            }
+        }
+    });
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/vector_source_impl.cpp b/src/mbgl/style/sources/vector_source_impl.cpp
index 158abf8575..aab62acf3f 100644
--- a/src/mbgl/style/sources/vector_source_impl.cpp
+++ b/src/mbgl/style/sources/vector_source_impl.cpp
@@ -1,16 +1,31 @@
 #include <mbgl/style/sources/vector_source_impl.hpp>
 #include <mbgl/renderer/sources/render_vector_source.hpp>
-#include <mbgl/util/constants.hpp>
 
 namespace mbgl {
 namespace style {
 
-VectorSource::Impl::Impl(std::string id_, Source& base_, variant<std::string, Tileset> urlOrTileset_)
-    : TileSourceImpl(SourceType::Vector, std::move(id_), base_, std::move(urlOrTileset_), util::tileSize) {
+VectorSource::Impl::Impl(std::string id_)
+    : Source::Impl(SourceType::Vector, std::move(id_)) {
+}
+
+VectorSource::Impl::Impl(const Impl& other, Tileset tileset_)
+    : Source::Impl(other),
+      tileset(std::move(tileset_)) {
+}
+
+optional<Tileset> VectorSource::Impl::getTileset() const {
+    return tileset;
+}
+
+optional<std::string> VectorSource::Impl::getAttribution() const {
+    if (!tileset) {
+        return {};
+    }
+    return tileset->attribution;
 }
 
 std::unique_ptr<RenderSource> VectorSource::Impl::createRenderSource() const {
-    return std::make_unique<RenderVectorSource>(*this);
+    return std::make_unique<RenderVectorSource>(staticImmutableCast<VectorSource::Impl>(immutableFromThis()));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/vector_source_impl.hpp b/src/mbgl/style/sources/vector_source_impl.hpp
index 844739948c..602d0e5bbb 100644
--- a/src/mbgl/style/sources/vector_source_impl.hpp
+++ b/src/mbgl/style/sources/vector_source_impl.hpp
@@ -1,16 +1,23 @@
 #pragma once
 
 #include <mbgl/style/sources/vector_source.hpp>
-#include <mbgl/style/tile_source_impl.hpp>
+#include <mbgl/style/source_impl.hpp>
 
 namespace mbgl {
 namespace style {
 
-class VectorSource::Impl : public TileSourceImpl {
+class VectorSource::Impl : public Source::Impl {
 public:
-    Impl(std::string id, Source&, variant<std::string, Tileset>);
+    Impl(std::string id);
+    Impl(const Impl&, Tileset);
 
+    optional<Tileset> getTileset() const;
+
+    optional<std::string> getAttribution() const final;
     std::unique_ptr<RenderSource> createRenderSource() const final;
+
+private:
+    optional<Tileset> tileset;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 9cd8cda1ec..2042bc1225 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -34,6 +34,7 @@
 #include <mbgl/renderer/render_line_layer.hpp>
 #include <mbgl/renderer/render_raster_layer.hpp>
 #include <mbgl/renderer/render_symbol_layer.hpp>
+#include <mbgl/renderer/style_diff.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/exception.hpp>
@@ -74,27 +75,19 @@ Style::Style(Scheduler& scheduler_, FileSource& fileSource_, float pixelRatio)
       spriteAtlas(std::make_unique<SpriteAtlas>(Size{ 1024, 1024 }, pixelRatio)),
       lineAtlas(std::make_unique<LineAtlas>(Size{ 256, 512 })),
       light(std::make_unique<Light>()),
-      renderLight(std::make_unique<RenderLight>(light->impl)),
+      renderLight(light->impl),
       observer(&nullObserver) {
     glyphAtlas->setObserver(this);
     spriteAtlas->setObserver(this);
-    light->impl->setObserver(this);
+    light->setObserver(this);
 }
 
 Style::~Style() {
-    for (const auto& source : sources) {
-        source->baseImpl->setObserver(nullptr);
-    }
-
     for (const auto& layer : layers) {
         if (auto* customLayer = layer->as<CustomLayer>()) {
-            customLayer->impl->deinitialize();
+            customLayer->impl().deinitialize();
         }
     }
-
-    glyphAtlas->setObserver(nullptr);
-    spriteAtlas->setObserver(nullptr);
-    light->impl->setObserver(nullptr);
 }
 
 bool Style::addClass(const std::string& className) {
@@ -136,7 +129,6 @@ void Style::setJSON(const std::string& json) {
     sources.clear();
     renderSources.clear();
     layers.clear();
-    renderLayers.clear();
     classes.clear();
     transitionOptions = {};
     updateBatch = {};
@@ -186,12 +178,8 @@ void Style::addSource(std::unique_ptr<Source> source) {
         throw std::runtime_error(msg.c_str());
     }
 
-    source->baseImpl->setObserver(this);
-    source->baseImpl->loadDescription(fileSource);
-
-    std::unique_ptr<RenderSource> renderSource = source->baseImpl->createRenderSource();
-    renderSource->setObserver(this);
-    renderSources.emplace_back(std::move(renderSource));
+    source->setObserver(this);
+    source->loadDescription(fileSource);
 
     sources.emplace_back(std::move(source));
 }
@@ -205,12 +193,8 @@ std::unique_ptr<Source> Style::removeSource(const std::string& id) {
         return nullptr;
     }
 
-    util::erase_if(renderSources, [&](const auto& source) {
-        return source->baseImpl.id == id;
-    });
-
     auto source = std::move(*it);
-    source->baseImpl->setObserver(nullptr);
+    source->setObserver(nullptr);
     sources.erase(it);
     updateBatch.sourceIDs.erase(id);
 
@@ -259,15 +243,13 @@ Layer* Style::addLayer(std::unique_ptr<Layer> layer, optional<std::string> befor
     }
 
     if (auto* customLayer = layer->as<CustomLayer>()) {
-        customLayer->impl->initialize();
+        customLayer->impl().initialize();
     }
 
-    layer->baseImpl->setObserver(this);
+    layer->setObserver(this);
     layer->accept(QueueSourceReloadVisitor { updateBatch });
 
-    auto added = layers.emplace(before ? findLayer(*before) : layers.end(), std::move(layer))->get();
-    renderLayers.emplace(before ? findRenderLayer(*before) : renderLayers.end(), added->baseImpl->createRenderLayer());
-    return std::move(added);
+    return layers.emplace(before ? findLayer(*before) : layers.end(), std::move(layer))->get();
 }
 
 std::unique_ptr<Layer> Style::removeLayer(const std::string& id) {
@@ -281,20 +263,19 @@ std::unique_ptr<Layer> Style::removeLayer(const std::string& id) {
     auto layer = std::move(*it);
 
     if (auto* customLayer = layer->as<CustomLayer>()) {
-        customLayer->impl->deinitialize();
+        customLayer->impl().deinitialize();
     }
 
-    layer->baseImpl->setObserver(nullptr);
+    layer->setObserver(nullptr);
     layers.erase(it);
-    removeRenderLayer(id);
     return layer;
 }
 
 std::vector<const RenderLayer*> Style::getRenderLayers() const {
     std::vector<const RenderLayer*> result;
     result.reserve(renderLayers.size());
-    for (const auto& layer : renderLayers) {
-        result.push_back(layer.get());
+    for (const auto& entry : renderLayers) {
+        result.push_back(entry.second.get());
     }
     return result;
 }
@@ -302,41 +283,20 @@ std::vector<const RenderLayer*> Style::getRenderLayers() const {
 std::vector<RenderLayer*> Style::getRenderLayers() {
     std::vector<RenderLayer*> result;
     result.reserve(renderLayers.size());
-    for (auto& layer : renderLayers) {
-        result.push_back(layer.get());
+    for (auto& entry : renderLayers) {
+        result.push_back(entry.second.get());
     }
     return result;
 }
 
-std::vector<std::unique_ptr<RenderLayer>>::const_iterator Style::findRenderLayer(const std::string& id) const {
-    return std::find_if(renderLayers.begin(), renderLayers.end(), [&](const auto& layer) {
-        return layer->baseImpl.id == id;
-    });
-}
-
 RenderLayer* Style::getRenderLayer(const std::string& id) const {
-    auto it = findRenderLayer(id);
-    return it != renderLayers.end() ? it->get() : nullptr;
-}
-
-void Style::removeRenderLayer(const std::string& id) {
-    auto it = std::find_if(renderLayers.begin(), renderLayers.end(), [&](const auto& layer) {
-        return layer->baseImpl.id == id;
-    });
-
-    if (it != renderLayers.end()) {
-        renderLayers.erase(it);
-    }
+    auto it = renderLayers.find(id);
+    return it != renderLayers.end() ? it->second.get() : nullptr;
 }
 
 void Style::setLight(std::unique_ptr<Light> light_) {
     light = std::move(light_);
-    light->impl->setObserver(this);
-
-    // Copy renderlight to preserve the initialised
-    // transitioning light properties
-    renderLight = renderLight->copy(light->impl);
-
+    light->setObserver(this);
     onLightChanged(*light);
 }
 
@@ -344,8 +304,8 @@ Light* Style::getLight() const {
     return light.get();
 }
 
-RenderLight* Style::getRenderLight() const {
-    return renderLight.get();
+const RenderLight& Style::getRenderLight() const {
+    return renderLight;
 }
 
 std::string Style::getName() const {
@@ -369,7 +329,8 @@ double Style::getDefaultPitch() const {
 }
 
 void Style::update(const UpdateParameters& parameters) {
-    bool zoomChanged = zoomHistory.update(parameters.transformState.getZoom(), parameters.timePoint);
+    const bool zoomChanged = zoomHistory.update(parameters.transformState.getZoom(), parameters.timePoint);
+    const bool classesChanged = parameters.updateFlags & Update::Classes;
 
     std::vector<ClassID> classIDs;
     for (const auto& className : classes) {
@@ -398,48 +359,111 @@ void Style::update(const UpdateParameters& parameters) {
                                         parameters.annotationManager,
                                         *this);
 
-    const bool cascade = parameters.updateFlags & Update::Classes;
-    const bool evaluate = cascade || zoomChanged || parameters.updateFlags & Update::RecalculateStyle;
+    // Update light.
+    const bool lightChanged = renderLight.impl != light->impl;
 
-    if (cascade) {
-        renderLight->transition(cascadeParameters);
+    if (lightChanged) {
+        renderLight.impl = light->impl;
+        renderLight.transition(cascadeParameters);
     }
 
-    if (evaluate || renderLight->hasTransition()) {
-        renderLight->evaluate(evaluationParameters);
+    if (lightChanged || zoomChanged || renderLight.hasTransition()) {
+        renderLight.evaluate(evaluationParameters);
     }
 
-    for (const auto& renderSource : renderSources) {
-        renderSource->enabled = false;
+
+    std::vector<Immutable<Source::Impl>> newSourceImpls;
+    newSourceImpls.reserve(sources.size());
+    for (const auto& source : sources) {
+        newSourceImpls.push_back(source->baseImpl);
     }
 
-    for (const auto& layer : renderLayers) {
-        if (cascade) {
-            layer->cascade(cascadeParameters);
+    const SourceDifference sourceDiff = diffSources(sourceImpls, newSourceImpls);
+    sourceImpls = std::move(newSourceImpls);
+
+    // Remove render layers for removed sources.
+    for (const auto& entry : sourceDiff.removed) {
+        renderLayers.erase(entry.first);
+    }
+
+    // Create render sources for newly added sources.
+    for (const auto& entry : sourceDiff.added) {
+        std::unique_ptr<RenderSource> renderSource = entry.second->createRenderSource();
+        renderSource->setObserver(this);
+        renderSources.emplace(entry.first, std::move(renderSource));
+    }
+
+    // Update render sources for changed sources.
+    for (const auto& entry : sourceDiff.changed) {
+        renderSources.at(entry.first)->setImpl(entry.second);
+    }
+
+
+    std::vector<Immutable<Layer::Impl>> newLayerImpls;
+    newLayerImpls.reserve(layers.size());
+    for (const auto& layer : layers) {
+        newLayerImpls.push_back(layer->baseImpl);
+    }
+
+    const LayerDifference layerDiff = diffLayers(layerImpls, newLayerImpls);
+    layerImpls = std::move(newLayerImpls);
+
+    // Remove render layers for removed layers.
+    for (const auto& entry : layerDiff.removed) {
+        renderLayers.erase(entry.first);
+    }
+
+    // Create render layers for newly added layers.
+    for (const auto& entry : layerDiff.added) {
+        renderLayers.emplace(entry.first, entry.second->createRenderLayer());
+    }
+
+    // Update render layers for changed layers.
+    for (const auto& entry : layerDiff.changed) {
+        renderLayers.at(entry.first)->setImpl(entry.second);
+    }
+
+    // Update layers for class and zoom changes.
+    for (const auto& entry : renderLayers) {
+        RenderLayer& layer = *entry.second;
+        const bool layerAdded = layerDiff.added.count(entry.first);
+        const bool layerChanged = layerDiff.changed.count(entry.first);
+
+        if (classesChanged || layerAdded || layerChanged) {
+            layer.cascade(cascadeParameters);
         }
 
-        if (evaluate || layer->hasTransition()) {
-            layer->evaluate(evaluationParameters);
+        if (classesChanged || layerAdded || layerChanged || zoomChanged || layer.hasTransition()) {
+            layer.evaluate(evaluationParameters);
         }
+    }
+
+
+    // Update tiles for each source.
+    for (const auto& entry : renderSources) {
+        entry.second->enabled = false;
+    }
 
-        if (layer->needsRendering(zoomHistory.lastZoom)) {
-            if (RenderSource* renderSource = getRenderSource(layer->baseImpl.source)) {
-                renderSource->enabled = true;
+    for (const auto& entry : renderLayers) {
+        RenderLayer& layer = *entry.second;
+        if (layer.needsRendering(zoomHistory.lastZoom)) {
+            if (RenderSource* source = getRenderSource(layer.baseImpl->source)) {
+                source->enabled = true;
             }
         }
     }
 
-    for (const auto& renderSource : renderSources) {
-        bool updated = updateBatch.sourceIDs.count(renderSource->baseImpl.id);
-        if (renderSource->enabled) {
+    for (const auto& entry : renderSources) {
+        bool updated = updateBatch.sourceIDs.count(entry.first);
+        if (entry.second->enabled) {
             if (updated) {
-                renderSource->reloadTiles();
+                entry.second->reloadTiles();
             }
-            renderSource->updateTiles(tileParameters);
+            entry.second->updateTiles(tileParameters);
         } else if (updated) {
-            renderSource->invalidateTiles();
+            entry.second->invalidateTiles();
         } else {
-            renderSource->removeTiles();
+            entry.second->removeTiles();
         }
     }
 
@@ -473,20 +497,17 @@ Source* Style::getSource(const std::string& id) const {
 }
 
 RenderSource* Style::getRenderSource(const std::string& id) const {
-    const auto it = std::find_if(renderSources.begin(), renderSources.end(), [&](const auto& source) {
-        return source->baseImpl.id == id;
-    });
-
-    return it != renderSources.end() ? it->get() : nullptr;
+    auto it = renderSources.find(id);
+    return it != renderSources.end() ? it->second.get() : nullptr;
 }
 
 bool Style::hasTransitions() const {
-    if (renderLight->hasTransition()) {
+    if (renderLight.hasTransition()) {
         return true;
     }
 
-    for (const auto& layer : renderLayers) {
-        if (layer->hasTransition()) {
+    for (const auto& entry : renderLayers) {
+        if (entry.second->hasTransition()) {
             return true;
         }
     }
@@ -500,13 +521,13 @@ bool Style::isLoaded() const {
     }
 
     for (const auto& source: sources) {
-        if (!source->baseImpl->loaded) {
+        if (!source->loaded) {
             return false;
         }
     }
 
-    for (const auto& renderSource: renderSources) {
-        if (!renderSource->isLoaded()) {
+    for (const auto& entry: renderSources) {
+        if (!entry.second->isLoaded()) {
             return false;
         }
     }
@@ -521,13 +542,16 @@ bool Style::isLoaded() const {
 RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const {
     RenderData result;
 
-    for (const auto& renderSource: renderSources) {
-        if (renderSource->enabled) {
-            result.sources.insert(renderSource.get());
+    for (const auto& entry : renderSources) {
+        if (entry.second->enabled) {
+            result.sources.insert(entry.second.get());
         }
     }
 
-    for (const auto& layer : renderLayers) {
+    for (const auto& layerImpl : layerImpls) {
+        const RenderLayer* layer = getRenderLayer(layerImpl->id);
+        assert(layer);
+
         if (!layer->needsRendering(zoomHistory.lastZoom)) {
             continue;
         }
@@ -539,7 +563,7 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
                 continue;
             }
             const BackgroundPaintProperties::Evaluated& paint = background->evaluated;
-            if (layer.get() == renderLayers[0].get() && paint.get<BackgroundPattern>().from.empty()) {
+            if (layerImpl.get() == layerImpls[0].get() && paint.get<BackgroundPattern>().from.empty()) {
                 // This is a solid background. We can use glClear().
                 result.backgroundColor = paint.get<BackgroundColor>() * paint.get<BackgroundOpacity>();
             } else {
@@ -554,9 +578,9 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
             continue;
         }
 
-        RenderSource* source = getRenderSource(layer->baseImpl.source);
+        RenderSource* source = getRenderSource(layer->baseImpl->source);
         if (!source) {
-            Log::Warning(Event::Render, "can't find source for layer '%s'", layer->baseImpl.id.c_str());
+            Log::Warning(Event::Render, "can't find source for layer '%s'", layer->baseImpl->id.c_str());
             continue;
         }
 
@@ -609,7 +633,7 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
                 }
             }
 
-            auto bucket = tile.tile.getBucket(*layer);
+            auto bucket = tile.tile.getBucket(*layer->baseImpl);
             if (bucket) {
                 sortedTilesForInsertion.emplace_back(tile);
                 tile.used = true;
@@ -641,8 +665,8 @@ std::vector<Feature> Style::queryRenderedFeatures(const ScreenLineString& geomet
             }
         }
     } else {
-        for (const auto& renderSource : renderSources) {
-            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, options);
+        for (const auto& entry : renderSources) {
+            auto sourceResults = entry.second->queryRenderedFeatures(geometry, transformState, options);
             std::move(sourceResults.begin(), sourceResults.end(), std::inserter(resultsByLayer, resultsByLayer.begin()));
         }
     }
@@ -654,11 +678,12 @@ std::vector<Feature> Style::queryRenderedFeatures(const ScreenLineString& geomet
     }
 
     // Combine all results based on the style layer order.
-    for (const auto& layer : renderLayers) {
+    for (const auto& layerImpl : layerImpls) {
+        const RenderLayer* layer = getRenderLayer(layerImpl->id);
         if (!layer->needsRendering(zoomHistory.lastZoom)) {
             continue;
         }
-        auto it = resultsByLayer.find(layer->baseImpl.id);
+        auto it = resultsByLayer.find(layer->baseImpl->id);
         if (it != resultsByLayer.end()) {
             std::move(it->second.begin(), it->second.end(), std::back_inserter(result));
         }
@@ -668,14 +693,14 @@ std::vector<Feature> Style::queryRenderedFeatures(const ScreenLineString& geomet
 }
 
 void Style::setSourceTileCacheSize(size_t size) {
-    for (const auto& renderSource : renderSources) {
-        renderSource->setCacheSize(size);
+    for (const auto& entry : renderSources) {
+        entry.second->setCacheSize(size);
     }
 }
 
 void Style::onLowMemory() {
-    for (const auto& renderSource : renderSources) {
-        renderSource->onLowMemory();
+    for (const auto& entry : renderSources) {
+        entry.second->onLowMemory();
     }
 }
 
@@ -714,8 +739,8 @@ void Style::onSourceError(Source& source, std::exception_ptr error) {
 
 void Style::onSourceDescriptionChanged(Source& source) {
     observer->onSourceDescriptionChanged(source);
-    if (!source.baseImpl->loaded) {
-        source.baseImpl->loadDescription(fileSource);
+    if (!source.loaded) {
+        source.loadDescription(fileSource);
     }
 }
 
@@ -726,7 +751,7 @@ void Style::onTileChanged(RenderSource&, const OverscaledTileID&) {
 void Style::onTileError(RenderSource& source, const OverscaledTileID& tileID, std::exception_ptr error) {
     lastError = error;
     Log::Error(Event::Style, "Failed to load tile %s for source %s: %s",
-               util::toString(tileID).c_str(), source.baseImpl.id.c_str(), util::toString(error).c_str());
+               util::toString(tileID).c_str(), source.baseImpl->id.c_str(), util::toString(error).c_str());
     observer->onResourceError(error);
 }
 
@@ -749,38 +774,34 @@ void Style::onLayerFilterChanged(Layer& layer) {
 
 void Style::onLayerVisibilityChanged(Layer& layer) {
     layer.accept(QueueSourceReloadVisitor { updateBatch });
-    observer->onUpdate(Update::RecalculateStyle);
+    observer->onUpdate(Update::Repaint);
 }
 
 void Style::onLayerPaintPropertyChanged(Layer&) {
-    observer->onUpdate(Update::RecalculateStyle | Update::Classes);
+    observer->onUpdate(Update::Repaint);
 }
 
 void Style::onLayerDataDrivenPaintPropertyChanged(Layer& layer) {
     layer.accept(QueueSourceReloadVisitor { updateBatch });
-    observer->onUpdate(Update::RecalculateStyle | Update::Classes);
+    observer->onUpdate(Update::Repaint);
 }
 
-void Style::onLayerLayoutPropertyChanged(Layer& layer, const char * property) {
+void Style::onLayerLayoutPropertyChanged(Layer& layer, const char *) {
     layer.accept(QueueSourceReloadVisitor { updateBatch });
-
-    // Recalculate the style for certain properties
-    observer->onUpdate((strcmp(property, "icon-size") == 0 || strcmp(property, "text-size") == 0)
-        ? Update::RecalculateStyle
-        : Update::Repaint);
+    observer->onUpdate(Update::Repaint);
 }
 
 void Style::onLightChanged(const Light&) {
-    observer->onUpdate(Update::Classes | Update::RecalculateStyle);
+    observer->onUpdate(Update::Repaint);
 }
 
 void Style::dumpDebugLogs() const {
     for (const auto& source : sources) {
-        source->baseImpl->dumpDebugLogs();
+        source->dumpDebugLogs();
     }
 
-    for (const auto& renderSource : renderSources) {
-        renderSource->dumpDebugLogs();
+    for (const auto& entry : renderSources) {
+        entry.second->dumpDebugLogs();
     }
 
     spriteAtlas->dumpDebugLogs();
diff --git a/src/mbgl/style/style.hpp b/src/mbgl/style/style.hpp
index 7d235dc665..04d3a11d55 100644
--- a/src/mbgl/style/style.hpp
+++ b/src/mbgl/style/style.hpp
@@ -3,10 +3,11 @@
 #include <mbgl/style/transition_options.hpp>
 #include <mbgl/style/observer.hpp>
 #include <mbgl/style/source_observer.hpp>
-#include <mbgl/renderer/render_source_observer.hpp>
 #include <mbgl/style/layer_observer.hpp>
 #include <mbgl/style/light_observer.hpp>
 #include <mbgl/style/update_batch.hpp>
+#include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/render_source_observer.hpp>
 #include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/renderer/render_light.hpp>
 #include <mbgl/text/glyph_atlas_observer.hpp>
@@ -35,8 +36,6 @@ class RenderData;
 class TransformState;
 class RenderedQueryOptions;
 class Scheduler;
-class RenderLayer;
-class RenderSource;
 class UpdateParameters;
 
 namespace style {
@@ -105,7 +104,7 @@ public:
 
     void setLight(std::unique_ptr<Light>);
     Light* getLight() const;
-    RenderLight* getRenderLight() const;
+    const RenderLight& getRenderLight() const;
 
     RenderData getRenderData(MapDebugOptions, float angle) const;
 
@@ -128,15 +127,10 @@ public:
 
 private:
     std::vector<std::unique_ptr<Source>> sources;
-    std::vector<std::unique_ptr<RenderSource>> renderSources;
-
     std::vector<std::unique_ptr<Layer>> layers;
-    std::vector<std::unique_ptr<RenderLayer>> renderLayers;
     std::vector<std::string> classes;
     TransitionOptions transitionOptions;
-
     std::unique_ptr<Light> light;
-    std::unique_ptr<RenderLight> renderLight;
 
     // Defaults
     std::string name;
@@ -145,8 +139,14 @@ private:
     double defaultBearing = 0;
     double defaultPitch = 0;
 
+    std::vector<Immutable<Source::Impl>> sourceImpls;
+    std::vector<Immutable<Layer::Impl>> layerImpls;
+
+    std::unordered_map<std::string, std::unique_ptr<RenderSource>> renderSources;
+    std::unordered_map<std::string, std::unique_ptr<RenderLayer>> renderLayers;
+    RenderLight renderLight;
+
     std::vector<std::unique_ptr<Layer>>::const_iterator findLayer(const std::string& layerID) const;
-    std::vector<std::unique_ptr<RenderLayer>>::const_iterator findRenderLayer(const std::string&) const;
 
     // GlyphStoreObserver implementation.
     void onGlyphsLoaded(const FontStack&, const GlyphRange&) override;
@@ -182,8 +182,6 @@ private:
     UpdateBatch updateBatch;
     ZoomHistory zoomHistory;
 
-    void removeRenderLayer(const std::string& layerID);
-
 public:
     bool loaded = false;
 };
diff --git a/src/mbgl/style/tile_source_impl.cpp b/src/mbgl/style/tile_source_impl.cpp
deleted file mode 100644
index 4d47221da9..0000000000
--- a/src/mbgl/style/tile_source_impl.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <mbgl/style/tile_source_impl.hpp>
-#include <mbgl/style/source_observer.hpp>
-#include <mbgl/style/conversion/json.hpp>
-#include <mbgl/style/conversion/tileset.hpp>
-#include <mbgl/util/mapbox.hpp>
-#include <mbgl/storage/file_source.hpp>
-
-namespace mbgl {
-namespace style {
-
-TileSourceImpl::TileSourceImpl(SourceType type_, std::string id_, Source& base_,
-                               variant<std::string, Tileset> urlOrTileset_,
-                               uint16_t tileSize_)
-    : Impl(type_, std::move(id_), base_),
-      urlOrTileset(std::move(urlOrTileset_)),
-      tileSize(tileSize_) {
-}
-
-TileSourceImpl::~TileSourceImpl() = default;
-
-void TileSourceImpl::loadDescription(FileSource& fileSource) {
-    if (urlOrTileset.is<Tileset>()) {
-        tileset = urlOrTileset.get<Tileset>();
-        loaded = true;
-        return;
-    }
-
-    if (req) {
-        return;
-    }
-
-    const auto& url = urlOrTileset.get<std::string>();
-    req = fileSource.request(Resource::source(url), [this, url](Response res) {
-        if (res.error) {
-            observer->onSourceError(base, std::make_exception_ptr(std::runtime_error(res.error->message)));
-        } else if (res.notModified) {
-            return;
-        } else if (res.noContent) {
-            observer->onSourceError(base, std::make_exception_ptr(std::runtime_error("unexpectedly empty TileJSON")));
-        } else {
-            conversion::Error error;
-            optional<Tileset> newTileset = conversion::convertJSON<Tileset>(*res.data, error);
-            if (!newTileset) {
-                observer->onSourceError(base, std::make_exception_ptr(std::runtime_error(error.message)));
-                return;
-            }
-
-            util::mapbox::canonicalizeTileset(*newTileset, url, type, tileSize);
-            bool attributionChanged = tileset.attribution != (*newTileset).attribution;
-
-            tileset = *newTileset;
-            loaded = true;
-
-            observer->onSourceLoaded(base);
-            if (attributionChanged) {
-                observer->onSourceChanged(base);
-            }
-        }
-    });
-}
-
-optional<Tileset> TileSourceImpl::getTileset() const {
-    if (loaded) {
-        return tileset;
-    }
-    return {};
-}
-
-optional<std::string> TileSourceImpl::getAttribution() const {
-    if (loaded && !tileset.attribution.empty()) {
-        return tileset.attribution;
-    } else {
-        return {};
-    }
-}
-
-} // namespace style
-} // namespace mbgl
diff --git a/src/mbgl/style/tile_source_impl.hpp b/src/mbgl/style/tile_source_impl.hpp
deleted file mode 100644
index 0e5a53add7..0000000000
--- a/src/mbgl/style/tile_source_impl.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <mbgl/style/source_impl.hpp>
-#include <mbgl/util/tileset.hpp>
-#include <mbgl/util/variant.hpp>
-#include <mbgl/util/optional.hpp>
-
-namespace mbgl {
-
-class AsyncRequest;
-
-namespace style {
-
-/*
-   Shared implementation for VectorSource and RasterSource. Should eventually
-   be refactored to use composition rather than inheritance.
-*/
-class TileSourceImpl : public Source::Impl {
-public:
-    TileSourceImpl(SourceType, std::string id, Source&,
-                   variant<std::string, Tileset> urlOrTileset,
-                   uint16_t tileSize);
-    ~TileSourceImpl() override;
-
-    void loadDescription(FileSource&) final;
-
-    uint16_t getTileSize() const {
-        return tileSize;
-    }
-
-    const variant<std::string, Tileset>& getURLOrTileset() const {
-        return urlOrTileset;
-    }
-
-    optional<std::string> getAttribution() const override;
-    optional<Tileset> getTileset() const;
-
-protected:
-    const variant<std::string, Tileset> urlOrTileset;
-    const uint16_t tileSize;
-
-    Tileset tileset;
-    std::unique_ptr<AsyncRequest> req;
-};
-
-} // namespace style
-} // namespace mbgl