[core] *LayerImpl::cascading ⇢ paint

22 files changed, 258 insertions, 258 deletions

diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 2937b115fc..50ec91d339 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -19,7 +19,7 @@ std::unique_ptr<Bucket> RenderBackgroundLayer::createBucket(const BucketParamete
 }
 
 void RenderBackgroundLayer::cascade(const CascadeParameters &parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index a9c451d28c..b7a2749e1b 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -20,7 +20,7 @@ std::unique_ptr<Bucket> RenderCircleLayer::createBucket(const BucketParameters&
 }
 
 void RenderCircleLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 2acdaecbc3..fa0b27cf9d 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -20,7 +20,7 @@ std::unique_ptr<Bucket> RenderFillExtrusionLayer::createBucket(const BucketParam
 }
 
 void RenderFillExtrusionLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 89fb9a364f..e030f5b38e 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -20,7 +20,7 @@ std::unique_ptr<Bucket> RenderFillLayer::createBucket(const BucketParameters& pa
 }
 
 void RenderFillLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index f54f4d9174..29067b6bfa 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -20,7 +20,7 @@ std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters& pa
 }
 
 void RenderLineLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 739f1d83ff..b235876894 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -18,7 +18,7 @@ std::unique_ptr<Bucket> RenderRasterLayer::createBucket(const BucketParameters&,
 }
 
 void RenderRasterLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 2d34054675..7d6b1cc039 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -34,7 +34,7 @@ std::unique_ptr<SymbolLayout> RenderSymbolLayer::createLayout(const BucketParame
 }
 
 void RenderSymbolLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().paint.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index 3d29b9819c..2aa15a779c 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -29,7 +29,7 @@ Mutable<BackgroundLayer::Impl> BackgroundLayer::mutableImpl() const {
 std::unique_ptr<Layer> BackgroundLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = BackgroundPaintProperties::Cascading();
+    impl_->paint = BackgroundPaintProperties::Cascading();
     return std::make_unique<BackgroundLayer>(std::move(impl_));
 }
 
@@ -72,26 +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().paint.template get<BackgroundColor>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getBackgroundColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundColor>().set(value, klass);
+    impl_->paint.template get<BackgroundColor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<BackgroundColor>().getTransition(klass);
 }
 
 PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
@@ -99,26 +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().paint.template get<BackgroundPattern>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getBackgroundPattern(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundPattern>().set(value, klass);
+    impl_->paint.template get<BackgroundPattern>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundPattern>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<BackgroundPattern>().getTransition(klass);
 }
 
 PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
@@ -126,26 +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().paint.template get<BackgroundOpacity>().get(klass);
 }
 
 void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getBackgroundOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundOpacity>().set(value, klass);
+    impl_->paint.template get<BackgroundOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void BackgroundLayer::setBackgroundOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<BackgroundOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<BackgroundOpacity>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp
index 8f17eb6d34..b50fccf00b 100644
--- a/src/mbgl/style/layers/background_layer_impl.hpp
+++ b/src/mbgl/style/layers/background_layer_impl.hpp
@@ -13,7 +13,7 @@ public:
 
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
-    BackgroundPaintProperties::Cascading cascading;
+    BackgroundPaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 6fcfe445a5..ea812748d0 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -29,7 +29,7 @@ Mutable<CircleLayer::Impl> CircleLayer::mutableImpl() const {
 std::unique_ptr<Layer> CircleLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = CirclePaintProperties::Cascading();
+    impl_->paint = CirclePaintProperties::Cascading();
     return std::make_unique<CircleLayer>(std::move(impl_));
 }
 
@@ -100,14 +100,14 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleRadius() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleRadius(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleRadius>().get(klass);
+    return impl().paint.template get<CircleRadius>().get(klass);
 }
 
 void CircleLayer::setCircleRadius(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleRadius(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleRadius>().set(value, klass);
+    impl_->paint.template get<CircleRadius>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -118,12 +118,12 @@ void CircleLayer::setCircleRadius(DataDrivenPropertyValue<float> value, const op
 
 void CircleLayer::setCircleRadiusTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleRadius>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleRadius>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() {
@@ -131,14 +131,14 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() {
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getCircleColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleColor>().get(klass);
+    return impl().paint.template get<CircleColor>().get(klass);
 }
 
 void CircleLayer::setCircleColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getCircleColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleColor>().set(value, klass);
+    impl_->paint.template get<CircleColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -149,12 +149,12 @@ void CircleLayer::setCircleColor(DataDrivenPropertyValue<Color> value, const opt
 
 void CircleLayer::setCircleColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() {
@@ -162,14 +162,14 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleBlur(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleBlur>().get(klass);
+    return impl().paint.template get<CircleBlur>().get(klass);
 }
 
 void CircleLayer::setCircleBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleBlur(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleBlur>().set(value, klass);
+    impl_->paint.template get<CircleBlur>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -180,12 +180,12 @@ void CircleLayer::setCircleBlur(DataDrivenPropertyValue<float> value, const opti
 
 void CircleLayer::setCircleBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleBlur>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleBlur>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
@@ -193,14 +193,14 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleOpacity>().get(klass);
+    return impl().paint.template get<CircleOpacity>().get(klass);
 }
 
 void CircleLayer::setCircleOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleOpacity>().set(value, klass);
+    impl_->paint.template get<CircleOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -211,12 +211,12 @@ void CircleLayer::setCircleOpacity(DataDrivenPropertyValue<float> value, const o
 
 void CircleLayer::setCircleOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleOpacity>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
@@ -224,26 +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().paint.template get<CircleTranslate>().get(klass);
 }
 
 void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getCircleTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleTranslate>().set(value, klass);
+    impl_->paint.template get<CircleTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCircleTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor() {
@@ -251,26 +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().paint.template get<CircleTranslateAnchor>().get(klass);
 }
 
 void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getCircleTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<CircleTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCircleTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
@@ -278,26 +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().paint.template get<CirclePitchScale>().get(klass);
 }
 
 void CircleLayer::setCirclePitchScale(PropertyValue<CirclePitchScaleType> value, const optional<std::string>& klass) {
     if (value == getCirclePitchScale(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CirclePitchScale>().set(value, klass);
+    impl_->paint.template get<CirclePitchScale>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void CircleLayer::setCirclePitchScaleTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CirclePitchScale>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CirclePitchScale>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
@@ -305,14 +305,14 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeWidth(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleStrokeWidth>().get(klass);
+    return impl().paint.template get<CircleStrokeWidth>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeWidth(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeWidth>().set(value, klass);
+    impl_->paint.template get<CircleStrokeWidth>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -323,12 +323,12 @@ void CircleLayer::setCircleStrokeWidth(DataDrivenPropertyValue<float> value, con
 
 void CircleLayer::setCircleStrokeWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeWidth>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleStrokeWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
@@ -336,14 +336,14 @@ DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
 }
 
 DataDrivenPropertyValue<Color> CircleLayer::getCircleStrokeColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleStrokeColor>().get(klass);
+    return impl().paint.template get<CircleStrokeColor>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeColor>().set(value, klass);
+    impl_->paint.template get<CircleStrokeColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -354,12 +354,12 @@ void CircleLayer::setCircleStrokeColor(DataDrivenPropertyValue<Color> value, con
 
 void CircleLayer::setCircleStrokeColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleStrokeColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
@@ -367,14 +367,14 @@ DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
 }
 
 DataDrivenPropertyValue<float> CircleLayer::getCircleStrokeOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<CircleStrokeOpacity>().get(klass);
+    return impl().paint.template get<CircleStrokeOpacity>().get(klass);
 }
 
 void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getCircleStrokeOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeOpacity>().set(value, klass);
+    impl_->paint.template get<CircleStrokeOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -385,12 +385,12 @@ void CircleLayer::setCircleStrokeOpacity(DataDrivenPropertyValue<float> value, c
 
 void CircleLayer::setCircleStrokeOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<CircleStrokeOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<CircleStrokeOpacity>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp
index 707f7e6103..0263ace62f 100644
--- a/src/mbgl/style/layers/circle_layer_impl.hpp
+++ b/src/mbgl/style/layers/circle_layer_impl.hpp
@@ -13,7 +13,7 @@ public:
 
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
-    CirclePaintProperties::Cascading cascading;
+    CirclePaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index 78a348f5c4..9a2ec36e15 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -29,7 +29,7 @@ Mutable<FillExtrusionLayer::Impl> FillExtrusionLayer::mutableImpl() const {
 std::unique_ptr<Layer> FillExtrusionLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = FillExtrusionPaintProperties::Cascading();
+    impl_->paint = FillExtrusionPaintProperties::Cascading();
     return std::make_unique<FillExtrusionLayer>(std::move(impl_));
 }
 
@@ -100,26 +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().paint.template get<FillExtrusionOpacity>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionOpacity>().set(value, klass);
+    impl_->paint.template get<FillExtrusionOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor() {
@@ -127,14 +127,14 @@ DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor(
 }
 
 DataDrivenPropertyValue<Color> FillExtrusionLayer::getFillExtrusionColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillExtrusionColor>().get(klass);
+    return impl().paint.template get<FillExtrusionColor>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionColor>().set(value, klass);
+    impl_->paint.template get<FillExtrusionColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -145,12 +145,12 @@ void FillExtrusionLayer::setFillExtrusionColor(DataDrivenPropertyValue<Color> va
 
 void FillExtrusionLayer::setFillExtrusionColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionTranslate() {
@@ -158,26 +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().paint.template get<FillExtrusionTranslate>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionTranslate>().set(value, klass);
+    impl_->paint.template get<FillExtrusionTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTranslateAnchor() {
@@ -185,26 +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().paint.template get<FillExtrusionTranslateAnchor>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<FillExtrusionTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern() {
@@ -212,26 +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().paint.template get<FillExtrusionPattern>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionPattern(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionPattern>().set(value, klass);
+    impl_->paint.template get<FillExtrusionPattern>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillExtrusionLayer::setFillExtrusionPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionPattern>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionPattern>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight() {
@@ -239,14 +239,14 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionHeight(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillExtrusionHeight>().get(klass);
+    return impl().paint.template get<FillExtrusionHeight>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionHeight(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionHeight>().set(value, klass);
+    impl_->paint.template get<FillExtrusionHeight>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -257,12 +257,12 @@ void FillExtrusionLayer::setFillExtrusionHeight(DataDrivenPropertyValue<float> v
 
 void FillExtrusionLayer::setFillExtrusionHeightTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionHeight>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionHeight>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() {
@@ -270,14 +270,14 @@ DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase()
 }
 
 DataDrivenPropertyValue<float> FillExtrusionLayer::getFillExtrusionBase(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillExtrusionBase>().get(klass);
+    return impl().paint.template get<FillExtrusionBase>().get(klass);
 }
 
 void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillExtrusionBase(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionBase>().set(value, klass);
+    impl_->paint.template get<FillExtrusionBase>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -288,12 +288,12 @@ void FillExtrusionLayer::setFillExtrusionBase(DataDrivenPropertyValue<float> val
 
 void FillExtrusionLayer::setFillExtrusionBaseTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillExtrusionBase>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillExtrusionBase>().getTransition(klass);
 }
 
 } // 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 edc481767e..4eadf56eda 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer_impl.hpp
@@ -13,7 +13,7 @@ public:
 
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
-    FillExtrusionPaintProperties::Cascading cascading;
+    FillExtrusionPaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 39f476c974..0031972842 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -29,7 +29,7 @@ Mutable<FillLayer::Impl> FillLayer::mutableImpl() const {
 std::unique_ptr<Layer> FillLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = FillPaintProperties::Cascading();
+    impl_->paint = FillPaintProperties::Cascading();
     return std::make_unique<FillLayer>(std::move(impl_));
 }
 
@@ -100,26 +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().paint.template get<FillAntialias>().get(klass);
 }
 
 void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) {
     if (value == getFillAntialias(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillAntialias>().set(value, klass);
+    impl_->paint.template get<FillAntialias>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillAntialiasTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillAntialias>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillAntialias>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() {
@@ -127,14 +127,14 @@ DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() {
 }
 
 DataDrivenPropertyValue<float> FillLayer::getFillOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillOpacity>().get(klass);
+    return impl().paint.template get<FillOpacity>().get(klass);
 }
 
 void FillLayer::setFillOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getFillOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillOpacity>().set(value, klass);
+    impl_->paint.template get<FillOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -145,12 +145,12 @@ void FillLayer::setFillOpacity(DataDrivenPropertyValue<float> value, const optio
 
 void FillLayer::setFillOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() {
@@ -158,14 +158,14 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() {
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getFillColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillColor>().get(klass);
+    return impl().paint.template get<FillColor>().get(klass);
 }
 
 void FillLayer::setFillColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillColor>().set(value, klass);
+    impl_->paint.template get<FillColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -176,12 +176,12 @@ void FillLayer::setFillColor(DataDrivenPropertyValue<Color> value, const optiona
 
 void FillLayer::setFillColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
@@ -189,14 +189,14 @@ DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
 }
 
 DataDrivenPropertyValue<Color> FillLayer::getFillOutlineColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<FillOutlineColor>().get(klass);
+    return impl().paint.template get<FillOutlineColor>().get(klass);
 }
 
 void FillLayer::setFillOutlineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getFillOutlineColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillOutlineColor>().set(value, klass);
+    impl_->paint.template get<FillOutlineColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -207,12 +207,12 @@ void FillLayer::setFillOutlineColor(DataDrivenPropertyValue<Color> value, const
 
 void FillLayer::setFillOutlineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillOutlineColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillOutlineColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
@@ -220,26 +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().paint.template get<FillTranslate>().get(klass);
 }
 
 void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getFillTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillTranslate>().set(value, klass);
+    impl_->paint.template get<FillTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
@@ -247,26 +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().paint.template get<FillTranslateAnchor>().get(klass);
 }
 
 void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getFillTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<FillTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
@@ -274,26 +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().paint.template get<FillPattern>().get(klass);
 }
 
 void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getFillPattern(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillPattern>().set(value, klass);
+    impl_->paint.template get<FillPattern>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void FillLayer::setFillPatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<FillPattern>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<FillPattern>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp
index 0ae146f859..1d64fe8fa4 100644
--- a/src/mbgl/style/layers/fill_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_layer_impl.hpp
@@ -13,7 +13,7 @@ public:
 
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
-    FillPaintProperties::Cascading cascading;
+    FillPaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 31a4332400..b07f7db307 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -40,7 +40,7 @@ Mutable<<%- camelize(type) %>Layer::Impl> <%- camelize(type) %>Layer::mutableImp
 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();
+    impl_->paint = <%- camelize(type) %>PaintProperties::Cascading();
     return std::make_unique<<%- camelize(type) %>Layer>(std::move(impl_));
 }
 
@@ -139,14 +139,14 @@ 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().paint.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;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<<%- camelize(property.name) %>>().set(value, klass);
+    impl_->paint.template get<<%- camelize(property.name) %>>().set(value, klass);
     baseImpl = std::move(impl_);
 <% if (isDataDriven(property)) { -%>
     if (value.isDataDriven()) {
@@ -161,12 +161,12 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass);
+    impl_->paint.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().paint.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 8b9085b48c..359078f913 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -29,7 +29,7 @@ Mutable<LineLayer::Impl> LineLayer::mutableImpl() const {
 std::unique_ptr<Layer> LineLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = LinePaintProperties::Cascading();
+    impl_->paint = LinePaintProperties::Cascading();
     return std::make_unique<LineLayer>(std::move(impl_));
 }
 
@@ -165,14 +165,14 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOpacity() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<LineOpacity>().get(klass);
+    return impl().paint.template get<LineOpacity>().get(klass);
 }
 
 void LineLayer::setLineOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineOpacity>().set(value, klass);
+    impl_->paint.template get<LineOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -183,12 +183,12 @@ void LineLayer::setLineOpacity(DataDrivenPropertyValue<float> value, const optio
 
 void LineLayer::setLineOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() {
@@ -196,14 +196,14 @@ DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() {
 }
 
 DataDrivenPropertyValue<Color> LineLayer::getLineColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<LineColor>().get(klass);
+    return impl().paint.template get<LineColor>().get(klass);
 }
 
 void LineLayer::setLineColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getLineColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineColor>().set(value, klass);
+    impl_->paint.template get<LineColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -214,12 +214,12 @@ void LineLayer::setLineColor(DataDrivenPropertyValue<Color> value, const optiona
 
 void LineLayer::setLineColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineColor>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
@@ -227,26 +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().paint.template get<LineTranslate>().get(klass);
 }
 
 void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getLineTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineTranslate>().set(value, klass);
+    impl_->paint.template get<LineTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
@@ -254,26 +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().paint.template get<LineTranslateAnchor>().get(klass);
 }
 
 void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getLineTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<LineTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineTranslateAnchor>().getTransition(klass);
 }
 
 PropertyValue<float> LineLayer::getDefaultLineWidth() {
@@ -281,26 +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().paint.template get<LineWidth>().get(klass);
 }
 
 void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineWidth(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineWidth>().set(value, klass);
+    impl_->paint.template get<LineWidth>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineWidth>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() {
@@ -308,14 +308,14 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineGapWidth(const optional<std::string>& klass) const {
-    return impl().cascading.template get<LineGapWidth>().get(klass);
+    return impl().paint.template get<LineGapWidth>().get(klass);
 }
 
 void LineLayer::setLineGapWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineGapWidth(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineGapWidth>().set(value, klass);
+    impl_->paint.template get<LineGapWidth>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -326,12 +326,12 @@ void LineLayer::setLineGapWidth(DataDrivenPropertyValue<float> value, const opti
 
 void LineLayer::setLineGapWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineGapWidth>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineGapWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() {
@@ -339,14 +339,14 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineOffset(const optional<std::string>& klass) const {
-    return impl().cascading.template get<LineOffset>().get(klass);
+    return impl().paint.template get<LineOffset>().get(klass);
 }
 
 void LineLayer::setLineOffset(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineOffset(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineOffset>().set(value, klass);
+    impl_->paint.template get<LineOffset>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -357,12 +357,12 @@ void LineLayer::setLineOffset(DataDrivenPropertyValue<float> value, const option
 
 void LineLayer::setLineOffsetTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineOffset>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineOffset>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() {
@@ -370,14 +370,14 @@ DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() {
 }
 
 DataDrivenPropertyValue<float> LineLayer::getLineBlur(const optional<std::string>& klass) const {
-    return impl().cascading.template get<LineBlur>().get(klass);
+    return impl().paint.template get<LineBlur>().get(klass);
 }
 
 void LineLayer::setLineBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getLineBlur(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineBlur>().set(value, klass);
+    impl_->paint.template get<LineBlur>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -388,12 +388,12 @@ void LineLayer::setLineBlur(DataDrivenPropertyValue<float> value, const optional
 
 void LineLayer::setLineBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineBlur>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineBlur>().getTransition(klass);
 }
 
 PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
@@ -401,26 +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().paint.template get<LineDasharray>().get(klass);
 }
 
 void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) {
     if (value == getLineDasharray(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineDasharray>().set(value, klass);
+    impl_->paint.template get<LineDasharray>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLineDasharrayTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LineDasharray>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LineDasharray>().getTransition(klass);
 }
 
 PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
@@ -428,26 +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().paint.template get<LinePattern>().get(klass);
 }
 
 void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
     if (value == getLinePattern(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LinePattern>().set(value, klass);
+    impl_->paint.template get<LinePattern>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void LineLayer::setLinePatternTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<LinePattern>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<LinePattern>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp
index decbf8451e..8328378a1f 100644
--- a/src/mbgl/style/layers/line_layer_impl.hpp
+++ b/src/mbgl/style/layers/line_layer_impl.hpp
@@ -14,7 +14,7 @@ public:
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     LineLayoutProperties layout;
-    LinePaintProperties::Cascading cascading;
+    LinePaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index 13c2d214ce..fb31d97657 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -29,7 +29,7 @@ Mutable<RasterLayer::Impl> RasterLayer::mutableImpl() const {
 std::unique_ptr<Layer> RasterLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = RasterPaintProperties::Cascading();
+    impl_->paint = RasterPaintProperties::Cascading();
     return std::make_unique<RasterLayer>(std::move(impl_));
 }
 
@@ -78,26 +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().paint.template get<RasterOpacity>().get(klass);
 }
 
 void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterOpacity>().set(value, klass);
+    impl_->paint.template get<RasterOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterOpacity>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
@@ -105,26 +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().paint.template get<RasterHueRotate>().get(klass);
 }
 
 void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterHueRotate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterHueRotate>().set(value, klass);
+    impl_->paint.template get<RasterHueRotate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterHueRotate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterHueRotate>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
@@ -132,26 +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().paint.template get<RasterBrightnessMin>().get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterBrightnessMin(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterBrightnessMin>().set(value, klass);
+    impl_->paint.template get<RasterBrightnessMin>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterBrightnessMin>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterBrightnessMin>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
@@ -159,26 +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().paint.template get<RasterBrightnessMax>().get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterBrightnessMax(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterBrightnessMax>().set(value, klass);
+    impl_->paint.template get<RasterBrightnessMax>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterBrightnessMax>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterBrightnessMax>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
@@ -186,26 +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().paint.template get<RasterSaturation>().get(klass);
 }
 
 void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterSaturation(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterSaturation>().set(value, klass);
+    impl_->paint.template get<RasterSaturation>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterSaturation>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterSaturation>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
@@ -213,26 +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().paint.template get<RasterContrast>().get(klass);
 }
 
 void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterContrast(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterContrast>().set(value, klass);
+    impl_->paint.template get<RasterContrast>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterContrast>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterContrast>().getTransition(klass);
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
@@ -240,26 +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().paint.template get<RasterFadeDuration>().get(klass);
 }
 
 void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getRasterFadeDuration(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterFadeDuration>().set(value, klass);
+    impl_->paint.template get<RasterFadeDuration>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<RasterFadeDuration>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<RasterFadeDuration>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp
index fbdbd9379b..13e5b3f4cf 100644
--- a/src/mbgl/style/layers/raster_layer_impl.hpp
+++ b/src/mbgl/style/layers/raster_layer_impl.hpp
@@ -13,7 +13,7 @@ public:
 
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
-    RasterPaintProperties::Cascading cascading;
+    RasterPaintProperties::Cascading paint;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 5a062997c4..75de1bb36b 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -29,7 +29,7 @@ Mutable<SymbolLayer::Impl> SymbolLayer::mutableImpl() const {
 std::unique_ptr<Layer> SymbolLayer::cloneRef(const std::string& id_) const {
     auto impl_ = mutableImpl();
     impl_->id = id_;
-    impl_->cascading = SymbolPaintProperties::Cascading();
+    impl_->paint = SymbolPaintProperties::Cascading();
     return std::make_unique<SymbolLayer>(std::move(impl_));
 }
 
@@ -645,14 +645,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconOpacity() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<IconOpacity>().get(klass);
+    return impl().paint.template get<IconOpacity>().get(klass);
 }
 
 void SymbolLayer::setIconOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconOpacity>().set(value, klass);
+    impl_->paint.template get<IconOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -663,12 +663,12 @@ void SymbolLayer::setIconOpacity(DataDrivenPropertyValue<float> value, const opt
 
 void SymbolLayer::setIconOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() {
@@ -676,14 +676,14 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getIconColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<IconColor>().get(klass);
+    return impl().paint.template get<IconColor>().get(klass);
 }
 
 void SymbolLayer::setIconColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconColor>().set(value, klass);
+    impl_->paint.template get<IconColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -694,12 +694,12 @@ void SymbolLayer::setIconColor(DataDrivenPropertyValue<Color> value, const optio
 
 void SymbolLayer::setIconColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
@@ -707,14 +707,14 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getIconHaloColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<IconHaloColor>().get(klass);
+    return impl().paint.template get<IconHaloColor>().get(klass);
 }
 
 void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconHaloColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloColor>().set(value, klass);
+    impl_->paint.template get<IconHaloColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -725,12 +725,12 @@ void SymbolLayer::setIconHaloColor(DataDrivenPropertyValue<Color> value, const o
 
 void SymbolLayer::setIconHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconHaloColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
@@ -738,14 +738,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconHaloWidth(const optional<std::string>& klass) const {
-    return impl().cascading.template get<IconHaloWidth>().get(klass);
+    return impl().paint.template get<IconHaloWidth>().get(klass);
 }
 
 void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloWidth(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloWidth>().set(value, klass);
+    impl_->paint.template get<IconHaloWidth>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -756,12 +756,12 @@ void SymbolLayer::setIconHaloWidth(DataDrivenPropertyValue<float> value, const o
 
 void SymbolLayer::setIconHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloWidth>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconHaloWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
@@ -769,14 +769,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getIconHaloBlur(const optional<std::string>& klass) const {
-    return impl().cascading.template get<IconHaloBlur>().get(klass);
+    return impl().paint.template get<IconHaloBlur>().get(klass);
 }
 
 void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloBlur(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloBlur>().set(value, klass);
+    impl_->paint.template get<IconHaloBlur>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -787,12 +787,12 @@ void SymbolLayer::setIconHaloBlur(DataDrivenPropertyValue<float> value, const op
 
 void SymbolLayer::setIconHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconHaloBlur>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconHaloBlur>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
@@ -800,26 +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().paint.template get<IconTranslate>().get(klass);
 }
 
 void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getIconTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconTranslate>().set(value, klass);
+    impl_->paint.template get<IconTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setIconTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor() {
@@ -827,26 +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().paint.template get<IconTranslateAnchor>().get(klass);
 }
 
 void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getIconTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<IconTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setIconTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<IconTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<IconTranslateAnchor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
@@ -854,14 +854,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextOpacity(const optional<std::string>& klass) const {
-    return impl().cascading.template get<TextOpacity>().get(klass);
+    return impl().paint.template get<TextOpacity>().get(klass);
 }
 
 void SymbolLayer::setTextOpacity(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextOpacity(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextOpacity>().set(value, klass);
+    impl_->paint.template get<TextOpacity>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -872,12 +872,12 @@ void SymbolLayer::setTextOpacity(DataDrivenPropertyValue<float> value, const opt
 
 void SymbolLayer::setTextOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextOpacity>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextOpacity>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() {
@@ -885,14 +885,14 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getTextColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<TextColor>().get(klass);
+    return impl().paint.template get<TextColor>().get(klass);
 }
 
 void SymbolLayer::setTextColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextColor>().set(value, klass);
+    impl_->paint.template get<TextColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -903,12 +903,12 @@ void SymbolLayer::setTextColor(DataDrivenPropertyValue<Color> value, const optio
 
 void SymbolLayer::setTextColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
@@ -916,14 +916,14 @@ DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
 }
 
 DataDrivenPropertyValue<Color> SymbolLayer::getTextHaloColor(const optional<std::string>& klass) const {
-    return impl().cascading.template get<TextHaloColor>().get(klass);
+    return impl().paint.template get<TextHaloColor>().get(klass);
 }
 
 void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextHaloColor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloColor>().set(value, klass);
+    impl_->paint.template get<TextHaloColor>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -934,12 +934,12 @@ void SymbolLayer::setTextHaloColor(DataDrivenPropertyValue<Color> value, const o
 
 void SymbolLayer::setTextHaloColorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloColor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextHaloColor>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
@@ -947,14 +947,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextHaloWidth(const optional<std::string>& klass) const {
-    return impl().cascading.template get<TextHaloWidth>().get(klass);
+    return impl().paint.template get<TextHaloWidth>().get(klass);
 }
 
 void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloWidth(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloWidth>().set(value, klass);
+    impl_->paint.template get<TextHaloWidth>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -965,12 +965,12 @@ void SymbolLayer::setTextHaloWidth(DataDrivenPropertyValue<float> value, const o
 
 void SymbolLayer::setTextHaloWidthTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloWidth>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextHaloWidth>().getTransition(klass);
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
@@ -978,14 +978,14 @@ DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
 }
 
 DataDrivenPropertyValue<float> SymbolLayer::getTextHaloBlur(const optional<std::string>& klass) const {
-    return impl().cascading.template get<TextHaloBlur>().get(klass);
+    return impl().paint.template get<TextHaloBlur>().get(klass);
 }
 
 void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloBlur(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloBlur>().set(value, klass);
+    impl_->paint.template get<TextHaloBlur>().set(value, klass);
     baseImpl = std::move(impl_);
     if (value.isDataDriven()) {
         observer->onLayerDataDrivenPaintPropertyChanged(*this);
@@ -996,12 +996,12 @@ void SymbolLayer::setTextHaloBlur(DataDrivenPropertyValue<float> value, const op
 
 void SymbolLayer::setTextHaloBlurTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextHaloBlur>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextHaloBlur>().getTransition(klass);
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
@@ -1009,26 +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().paint.template get<TextTranslate>().get(klass);
 }
 
 void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getTextTranslate(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextTranslate>().set(value, klass);
+    impl_->paint.template get<TextTranslate>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setTextTranslateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextTranslate>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextTranslate>().getTransition(klass);
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor() {
@@ -1036,26 +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().paint.template get<TextTranslateAnchor>().get(klass);
 }
 
 void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getTextTranslateAnchor(klass))
         return;
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextTranslateAnchor>().set(value, klass);
+    impl_->paint.template get<TextTranslateAnchor>().set(value, klass);
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
 void SymbolLayer::setTextTranslateAnchorTransition(const TransitionOptions& value, const optional<std::string>& klass) {
     auto impl_ = mutableImpl();
-    impl_->cascading.template get<TextTranslateAnchor>().setTransition(value, klass);
+    impl_->paint.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().paint.template get<TextTranslateAnchor>().getTransition(klass);
 }
 
 } // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp
index a20d001e0e..d961dbb0b9 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.hpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.hpp
@@ -14,7 +14,7 @@ public:
     void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
 
     SymbolLayoutProperties layout;
-    SymbolPaintProperties::Cascading cascading;
+    SymbolPaintProperties::Cascading paint;
 };
 
 } // namespace style