[core] Use mbgl::underlying_type in style propertiesupstream/style-light-setproperty

12 files changed, 228 insertions, 216 deletions

diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index 3c7a2a7569..1693c47204 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -147,7 +148,7 @@ TransitionOptions BackgroundLayer::getBackgroundPatternTransition() const {
 using namespace conversion;
 
 optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         BackgroundColor,
         BackgroundOpacity,
         BackgroundPattern,
@@ -157,12 +158,12 @@ optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "background-color", static_cast<uint8_t>(Property::BackgroundColor) },
-        { "background-opacity", static_cast<uint8_t>(Property::BackgroundOpacity) },
-        { "background-pattern", static_cast<uint8_t>(Property::BackgroundPattern) },
-        { "background-color-transition", static_cast<uint8_t>(Property::BackgroundColorTransition) },
-        { "background-opacity-transition", static_cast<uint8_t>(Property::BackgroundOpacityTransition) },
-        { "background-pattern-transition", static_cast<uint8_t>(Property::BackgroundPatternTransition) }
+        { "background-color", mbgl::underlying_type(Property::BackgroundColor) },
+        { "background-opacity", mbgl::underlying_type(Property::BackgroundOpacity) },
+        { "background-pattern", mbgl::underlying_type(Property::BackgroundPattern) },
+        { "background-color-transition", mbgl::underlying_type(Property::BackgroundColorTransition) },
+        { "background-opacity-transition", mbgl::underlying_type(Property::BackgroundOpacityTransition) },
+        { "background-pattern-transition", mbgl::underlying_type(Property::BackgroundPatternTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 8c3debd1ac..2293ed222e 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -363,7 +364,7 @@ TransitionOptions CircleLayer::getCircleTranslateAnchorTransition() const {
 using namespace conversion;
 
 optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         CircleBlur,
         CircleColor,
         CircleOpacity,
@@ -389,28 +390,28 @@ optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Con
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "circle-blur", static_cast<uint8_t>(Property::CircleBlur) },
-        { "circle-color", static_cast<uint8_t>(Property::CircleColor) },
-        { "circle-opacity", static_cast<uint8_t>(Property::CircleOpacity) },
-        { "circle-pitch-alignment", static_cast<uint8_t>(Property::CirclePitchAlignment) },
-        { "circle-pitch-scale", static_cast<uint8_t>(Property::CirclePitchScale) },
-        { "circle-radius", static_cast<uint8_t>(Property::CircleRadius) },
-        { "circle-stroke-color", static_cast<uint8_t>(Property::CircleStrokeColor) },
-        { "circle-stroke-opacity", static_cast<uint8_t>(Property::CircleStrokeOpacity) },
-        { "circle-stroke-width", static_cast<uint8_t>(Property::CircleStrokeWidth) },
-        { "circle-translate", static_cast<uint8_t>(Property::CircleTranslate) },
-        { "circle-translate-anchor", static_cast<uint8_t>(Property::CircleTranslateAnchor) },
-        { "circle-blur-transition", static_cast<uint8_t>(Property::CircleBlurTransition) },
-        { "circle-color-transition", static_cast<uint8_t>(Property::CircleColorTransition) },
-        { "circle-opacity-transition", static_cast<uint8_t>(Property::CircleOpacityTransition) },
-        { "circle-pitch-alignment-transition", static_cast<uint8_t>(Property::CirclePitchAlignmentTransition) },
-        { "circle-pitch-scale-transition", static_cast<uint8_t>(Property::CirclePitchScaleTransition) },
-        { "circle-radius-transition", static_cast<uint8_t>(Property::CircleRadiusTransition) },
-        { "circle-stroke-color-transition", static_cast<uint8_t>(Property::CircleStrokeColorTransition) },
-        { "circle-stroke-opacity-transition", static_cast<uint8_t>(Property::CircleStrokeOpacityTransition) },
-        { "circle-stroke-width-transition", static_cast<uint8_t>(Property::CircleStrokeWidthTransition) },
-        { "circle-translate-transition", static_cast<uint8_t>(Property::CircleTranslateTransition) },
-        { "circle-translate-anchor-transition", static_cast<uint8_t>(Property::CircleTranslateAnchorTransition) }
+        { "circle-blur", mbgl::underlying_type(Property::CircleBlur) },
+        { "circle-color", mbgl::underlying_type(Property::CircleColor) },
+        { "circle-opacity", mbgl::underlying_type(Property::CircleOpacity) },
+        { "circle-pitch-alignment", mbgl::underlying_type(Property::CirclePitchAlignment) },
+        { "circle-pitch-scale", mbgl::underlying_type(Property::CirclePitchScale) },
+        { "circle-radius", mbgl::underlying_type(Property::CircleRadius) },
+        { "circle-stroke-color", mbgl::underlying_type(Property::CircleStrokeColor) },
+        { "circle-stroke-opacity", mbgl::underlying_type(Property::CircleStrokeOpacity) },
+        { "circle-stroke-width", mbgl::underlying_type(Property::CircleStrokeWidth) },
+        { "circle-translate", mbgl::underlying_type(Property::CircleTranslate) },
+        { "circle-translate-anchor", mbgl::underlying_type(Property::CircleTranslateAnchor) },
+        { "circle-blur-transition", mbgl::underlying_type(Property::CircleBlurTransition) },
+        { "circle-color-transition", mbgl::underlying_type(Property::CircleColorTransition) },
+        { "circle-opacity-transition", mbgl::underlying_type(Property::CircleOpacityTransition) },
+        { "circle-pitch-alignment-transition", mbgl::underlying_type(Property::CirclePitchAlignmentTransition) },
+        { "circle-pitch-scale-transition", mbgl::underlying_type(Property::CirclePitchScaleTransition) },
+        { "circle-radius-transition", mbgl::underlying_type(Property::CircleRadiusTransition) },
+        { "circle-stroke-color-transition", mbgl::underlying_type(Property::CircleStrokeColorTransition) },
+        { "circle-stroke-opacity-transition", mbgl::underlying_type(Property::CircleStrokeOpacityTransition) },
+        { "circle-stroke-width-transition", mbgl::underlying_type(Property::CircleStrokeWidthTransition) },
+        { "circle-translate-transition", mbgl::underlying_type(Property::CircleTranslateTransition) },
+        { "circle-translate-anchor-transition", mbgl::underlying_type(Property::CircleTranslateAnchorTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index 2c07cc56c5..50e32cf812 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -282,7 +283,7 @@ TransitionOptions FillExtrusionLayer::getFillExtrusionVerticalGradientTransition
 using namespace conversion;
 
 optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         FillExtrusionBase,
         FillExtrusionColor,
         FillExtrusionHeight,
@@ -302,22 +303,22 @@ optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, co
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "fill-extrusion-base", static_cast<uint8_t>(Property::FillExtrusionBase) },
-        { "fill-extrusion-color", static_cast<uint8_t>(Property::FillExtrusionColor) },
-        { "fill-extrusion-height", static_cast<uint8_t>(Property::FillExtrusionHeight) },
-        { "fill-extrusion-opacity", static_cast<uint8_t>(Property::FillExtrusionOpacity) },
-        { "fill-extrusion-pattern", static_cast<uint8_t>(Property::FillExtrusionPattern) },
-        { "fill-extrusion-translate", static_cast<uint8_t>(Property::FillExtrusionTranslate) },
-        { "fill-extrusion-translate-anchor", static_cast<uint8_t>(Property::FillExtrusionTranslateAnchor) },
-        { "fill-extrusion-vertical-gradient", static_cast<uint8_t>(Property::FillExtrusionVerticalGradient) },
-        { "fill-extrusion-base-transition", static_cast<uint8_t>(Property::FillExtrusionBaseTransition) },
-        { "fill-extrusion-color-transition", static_cast<uint8_t>(Property::FillExtrusionColorTransition) },
-        { "fill-extrusion-height-transition", static_cast<uint8_t>(Property::FillExtrusionHeightTransition) },
-        { "fill-extrusion-opacity-transition", static_cast<uint8_t>(Property::FillExtrusionOpacityTransition) },
-        { "fill-extrusion-pattern-transition", static_cast<uint8_t>(Property::FillExtrusionPatternTransition) },
-        { "fill-extrusion-translate-transition", static_cast<uint8_t>(Property::FillExtrusionTranslateTransition) },
-        { "fill-extrusion-translate-anchor-transition", static_cast<uint8_t>(Property::FillExtrusionTranslateAnchorTransition) },
-        { "fill-extrusion-vertical-gradient-transition", static_cast<uint8_t>(Property::FillExtrusionVerticalGradientTransition) }
+        { "fill-extrusion-base", mbgl::underlying_type(Property::FillExtrusionBase) },
+        { "fill-extrusion-color", mbgl::underlying_type(Property::FillExtrusionColor) },
+        { "fill-extrusion-height", mbgl::underlying_type(Property::FillExtrusionHeight) },
+        { "fill-extrusion-opacity", mbgl::underlying_type(Property::FillExtrusionOpacity) },
+        { "fill-extrusion-pattern", mbgl::underlying_type(Property::FillExtrusionPattern) },
+        { "fill-extrusion-translate", mbgl::underlying_type(Property::FillExtrusionTranslate) },
+        { "fill-extrusion-translate-anchor", mbgl::underlying_type(Property::FillExtrusionTranslateAnchor) },
+        { "fill-extrusion-vertical-gradient", mbgl::underlying_type(Property::FillExtrusionVerticalGradient) },
+        { "fill-extrusion-base-transition", mbgl::underlying_type(Property::FillExtrusionBaseTransition) },
+        { "fill-extrusion-color-transition", mbgl::underlying_type(Property::FillExtrusionColorTransition) },
+        { "fill-extrusion-height-transition", mbgl::underlying_type(Property::FillExtrusionHeightTransition) },
+        { "fill-extrusion-opacity-transition", mbgl::underlying_type(Property::FillExtrusionOpacityTransition) },
+        { "fill-extrusion-pattern-transition", mbgl::underlying_type(Property::FillExtrusionPatternTransition) },
+        { "fill-extrusion-translate-transition", mbgl::underlying_type(Property::FillExtrusionTranslateTransition) },
+        { "fill-extrusion-translate-anchor-transition", mbgl::underlying_type(Property::FillExtrusionTranslateAnchorTransition) },
+        { "fill-extrusion-vertical-gradient-transition", mbgl::underlying_type(Property::FillExtrusionVerticalGradientTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 0aa19b834a..e08c8f3962 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -255,7 +256,7 @@ TransitionOptions FillLayer::getFillTranslateAnchorTransition() const {
 using namespace conversion;
 
 optional<Error> FillLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         FillAntialias,
         FillColor,
         FillOpacity,
@@ -273,20 +274,20 @@ optional<Error> FillLayer::setPaintProperty(const std::string& name, const Conve
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "fill-antialias", static_cast<uint8_t>(Property::FillAntialias) },
-        { "fill-color", static_cast<uint8_t>(Property::FillColor) },
-        { "fill-opacity", static_cast<uint8_t>(Property::FillOpacity) },
-        { "fill-outline-color", static_cast<uint8_t>(Property::FillOutlineColor) },
-        { "fill-pattern", static_cast<uint8_t>(Property::FillPattern) },
-        { "fill-translate", static_cast<uint8_t>(Property::FillTranslate) },
-        { "fill-translate-anchor", static_cast<uint8_t>(Property::FillTranslateAnchor) },
-        { "fill-antialias-transition", static_cast<uint8_t>(Property::FillAntialiasTransition) },
-        { "fill-color-transition", static_cast<uint8_t>(Property::FillColorTransition) },
-        { "fill-opacity-transition", static_cast<uint8_t>(Property::FillOpacityTransition) },
-        { "fill-outline-color-transition", static_cast<uint8_t>(Property::FillOutlineColorTransition) },
-        { "fill-pattern-transition", static_cast<uint8_t>(Property::FillPatternTransition) },
-        { "fill-translate-transition", static_cast<uint8_t>(Property::FillTranslateTransition) },
-        { "fill-translate-anchor-transition", static_cast<uint8_t>(Property::FillTranslateAnchorTransition) }
+        { "fill-antialias", mbgl::underlying_type(Property::FillAntialias) },
+        { "fill-color", mbgl::underlying_type(Property::FillColor) },
+        { "fill-opacity", mbgl::underlying_type(Property::FillOpacity) },
+        { "fill-outline-color", mbgl::underlying_type(Property::FillOutlineColor) },
+        { "fill-pattern", mbgl::underlying_type(Property::FillPattern) },
+        { "fill-translate", mbgl::underlying_type(Property::FillTranslate) },
+        { "fill-translate-anchor", mbgl::underlying_type(Property::FillTranslateAnchor) },
+        { "fill-antialias-transition", mbgl::underlying_type(Property::FillAntialiasTransition) },
+        { "fill-color-transition", mbgl::underlying_type(Property::FillColorTransition) },
+        { "fill-opacity-transition", mbgl::underlying_type(Property::FillOpacityTransition) },
+        { "fill-outline-color-transition", mbgl::underlying_type(Property::FillOutlineColorTransition) },
+        { "fill-pattern-transition", mbgl::underlying_type(Property::FillPatternTransition) },
+        { "fill-translate-transition", mbgl::underlying_type(Property::FillTranslateTransition) },
+        { "fill-translate-anchor-transition", mbgl::underlying_type(Property::FillTranslateAnchorTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/heatmap_layer.cpp b/src/mbgl/style/layers/heatmap_layer.cpp
index d35cb10b78..cb99f76a51 100644
--- a/src/mbgl/style/layers/heatmap_layer.cpp
+++ b/src/mbgl/style/layers/heatmap_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -203,7 +204,7 @@ TransitionOptions HeatmapLayer::getHeatmapWeightTransition() const {
 using namespace conversion;
 
 optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         HeatmapColor,
         HeatmapIntensity,
         HeatmapOpacity,
@@ -217,16 +218,16 @@ optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Co
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "heatmap-color", static_cast<uint8_t>(Property::HeatmapColor) },
-        { "heatmap-intensity", static_cast<uint8_t>(Property::HeatmapIntensity) },
-        { "heatmap-opacity", static_cast<uint8_t>(Property::HeatmapOpacity) },
-        { "heatmap-radius", static_cast<uint8_t>(Property::HeatmapRadius) },
-        { "heatmap-weight", static_cast<uint8_t>(Property::HeatmapWeight) },
-        { "heatmap-color-transition", static_cast<uint8_t>(Property::HeatmapColorTransition) },
-        { "heatmap-intensity-transition", static_cast<uint8_t>(Property::HeatmapIntensityTransition) },
-        { "heatmap-opacity-transition", static_cast<uint8_t>(Property::HeatmapOpacityTransition) },
-        { "heatmap-radius-transition", static_cast<uint8_t>(Property::HeatmapRadiusTransition) },
-        { "heatmap-weight-transition", static_cast<uint8_t>(Property::HeatmapWeightTransition) }
+        { "heatmap-color", mbgl::underlying_type(Property::HeatmapColor) },
+        { "heatmap-intensity", mbgl::underlying_type(Property::HeatmapIntensity) },
+        { "heatmap-opacity", mbgl::underlying_type(Property::HeatmapOpacity) },
+        { "heatmap-radius", mbgl::underlying_type(Property::HeatmapRadius) },
+        { "heatmap-weight", mbgl::underlying_type(Property::HeatmapWeight) },
+        { "heatmap-color-transition", mbgl::underlying_type(Property::HeatmapColorTransition) },
+        { "heatmap-intensity-transition", mbgl::underlying_type(Property::HeatmapIntensityTransition) },
+        { "heatmap-opacity-transition", mbgl::underlying_type(Property::HeatmapOpacityTransition) },
+        { "heatmap-radius-transition", mbgl::underlying_type(Property::HeatmapRadiusTransition) },
+        { "heatmap-weight-transition", mbgl::underlying_type(Property::HeatmapWeightTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/hillshade_layer.cpp b/src/mbgl/style/layers/hillshade_layer.cpp
index ba22ab25ab..95a395ef25 100644
--- a/src/mbgl/style/layers/hillshade_layer.cpp
+++ b/src/mbgl/style/layers/hillshade_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -228,7 +229,7 @@ TransitionOptions HillshadeLayer::getHillshadeShadowColorTransition() const {
 using namespace conversion;
 
 optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         HillshadeAccentColor,
         HillshadeExaggeration,
         HillshadeHighlightColor,
@@ -244,18 +245,18 @@ optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "hillshade-accent-color", static_cast<uint8_t>(Property::HillshadeAccentColor) },
-        { "hillshade-exaggeration", static_cast<uint8_t>(Property::HillshadeExaggeration) },
-        { "hillshade-highlight-color", static_cast<uint8_t>(Property::HillshadeHighlightColor) },
-        { "hillshade-illumination-anchor", static_cast<uint8_t>(Property::HillshadeIlluminationAnchor) },
-        { "hillshade-illumination-direction", static_cast<uint8_t>(Property::HillshadeIlluminationDirection) },
-        { "hillshade-shadow-color", static_cast<uint8_t>(Property::HillshadeShadowColor) },
-        { "hillshade-accent-color-transition", static_cast<uint8_t>(Property::HillshadeAccentColorTransition) },
-        { "hillshade-exaggeration-transition", static_cast<uint8_t>(Property::HillshadeExaggerationTransition) },
-        { "hillshade-highlight-color-transition", static_cast<uint8_t>(Property::HillshadeHighlightColorTransition) },
-        { "hillshade-illumination-anchor-transition", static_cast<uint8_t>(Property::HillshadeIlluminationAnchorTransition) },
-        { "hillshade-illumination-direction-transition", static_cast<uint8_t>(Property::HillshadeIlluminationDirectionTransition) },
-        { "hillshade-shadow-color-transition", static_cast<uint8_t>(Property::HillshadeShadowColorTransition) }
+        { "hillshade-accent-color", mbgl::underlying_type(Property::HillshadeAccentColor) },
+        { "hillshade-exaggeration", mbgl::underlying_type(Property::HillshadeExaggeration) },
+        { "hillshade-highlight-color", mbgl::underlying_type(Property::HillshadeHighlightColor) },
+        { "hillshade-illumination-anchor", mbgl::underlying_type(Property::HillshadeIlluminationAnchor) },
+        { "hillshade-illumination-direction", mbgl::underlying_type(Property::HillshadeIlluminationDirection) },
+        { "hillshade-shadow-color", mbgl::underlying_type(Property::HillshadeShadowColor) },
+        { "hillshade-accent-color-transition", mbgl::underlying_type(Property::HillshadeAccentColorTransition) },
+        { "hillshade-exaggeration-transition", mbgl::underlying_type(Property::HillshadeExaggerationTransition) },
+        { "hillshade-highlight-color-transition", mbgl::underlying_type(Property::HillshadeHighlightColorTransition) },
+        { "hillshade-illumination-anchor-transition", mbgl::underlying_type(Property::HillshadeIlluminationAnchorTransition) },
+        { "hillshade-illumination-direction-transition", mbgl::underlying_type(Property::HillshadeIlluminationDirectionTransition) },
+        { "hillshade-shadow-color-transition", mbgl::underlying_type(Property::HillshadeShadowColorTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 189857434f..da34565461 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -14,6 +14,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -176,7 +177,7 @@ TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>T
 using namespace conversion;
 
 optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
 <% for (const property of paintProperties) { -%>
         <%- camelize(property.name) %>,
 <% } -%>
@@ -186,8 +187,8 @@ optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string&
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        <%- paintProperties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n        ') %>,
-        <%- paintProperties.map(p => `{ "${p.name}-transition", static_cast<uint8_t>(Property::${camelize(p.name)}Transition) }`).join(',\n        ') %>
+        <%- paintProperties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n        ') %>,
+        <%- paintProperties.map(p => `{ "${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition) }`).join(',\n        ') %>
     });
 
     const auto it = properties.find(name.c_str());
@@ -254,7 +255,7 @@ optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string&
 <% } -%>
     };
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        <%- layoutProperties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n        ') %>
+        <%- layoutProperties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n        ') %>
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index 878816f6e4..deb85cad66 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -429,7 +430,7 @@ TransitionOptions LineLayer::getLineWidthTransition() const {
 using namespace conversion;
 
 optional<Error> LineLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         LineBlur,
         LineColor,
         LineDasharray,
@@ -455,28 +456,28 @@ optional<Error> LineLayer::setPaintProperty(const std::string& name, const Conve
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "line-blur", static_cast<uint8_t>(Property::LineBlur) },
-        { "line-color", static_cast<uint8_t>(Property::LineColor) },
-        { "line-dasharray", static_cast<uint8_t>(Property::LineDasharray) },
-        { "line-gap-width", static_cast<uint8_t>(Property::LineGapWidth) },
-        { "line-gradient", static_cast<uint8_t>(Property::LineGradient) },
-        { "line-offset", static_cast<uint8_t>(Property::LineOffset) },
-        { "line-opacity", static_cast<uint8_t>(Property::LineOpacity) },
-        { "line-pattern", static_cast<uint8_t>(Property::LinePattern) },
-        { "line-translate", static_cast<uint8_t>(Property::LineTranslate) },
-        { "line-translate-anchor", static_cast<uint8_t>(Property::LineTranslateAnchor) },
-        { "line-width", static_cast<uint8_t>(Property::LineWidth) },
-        { "line-blur-transition", static_cast<uint8_t>(Property::LineBlurTransition) },
-        { "line-color-transition", static_cast<uint8_t>(Property::LineColorTransition) },
-        { "line-dasharray-transition", static_cast<uint8_t>(Property::LineDasharrayTransition) },
-        { "line-gap-width-transition", static_cast<uint8_t>(Property::LineGapWidthTransition) },
-        { "line-gradient-transition", static_cast<uint8_t>(Property::LineGradientTransition) },
-        { "line-offset-transition", static_cast<uint8_t>(Property::LineOffsetTransition) },
-        { "line-opacity-transition", static_cast<uint8_t>(Property::LineOpacityTransition) },
-        { "line-pattern-transition", static_cast<uint8_t>(Property::LinePatternTransition) },
-        { "line-translate-transition", static_cast<uint8_t>(Property::LineTranslateTransition) },
-        { "line-translate-anchor-transition", static_cast<uint8_t>(Property::LineTranslateAnchorTransition) },
-        { "line-width-transition", static_cast<uint8_t>(Property::LineWidthTransition) }
+        { "line-blur", mbgl::underlying_type(Property::LineBlur) },
+        { "line-color", mbgl::underlying_type(Property::LineColor) },
+        { "line-dasharray", mbgl::underlying_type(Property::LineDasharray) },
+        { "line-gap-width", mbgl::underlying_type(Property::LineGapWidth) },
+        { "line-gradient", mbgl::underlying_type(Property::LineGradient) },
+        { "line-offset", mbgl::underlying_type(Property::LineOffset) },
+        { "line-opacity", mbgl::underlying_type(Property::LineOpacity) },
+        { "line-pattern", mbgl::underlying_type(Property::LinePattern) },
+        { "line-translate", mbgl::underlying_type(Property::LineTranslate) },
+        { "line-translate-anchor", mbgl::underlying_type(Property::LineTranslateAnchor) },
+        { "line-width", mbgl::underlying_type(Property::LineWidth) },
+        { "line-blur-transition", mbgl::underlying_type(Property::LineBlurTransition) },
+        { "line-color-transition", mbgl::underlying_type(Property::LineColorTransition) },
+        { "line-dasharray-transition", mbgl::underlying_type(Property::LineDasharrayTransition) },
+        { "line-gap-width-transition", mbgl::underlying_type(Property::LineGapWidthTransition) },
+        { "line-gradient-transition", mbgl::underlying_type(Property::LineGradientTransition) },
+        { "line-offset-transition", mbgl::underlying_type(Property::LineOffsetTransition) },
+        { "line-opacity-transition", mbgl::underlying_type(Property::LineOpacityTransition) },
+        { "line-pattern-transition", mbgl::underlying_type(Property::LinePatternTransition) },
+        { "line-translate-transition", mbgl::underlying_type(Property::LineTranslateTransition) },
+        { "line-translate-anchor-transition", mbgl::underlying_type(Property::LineTranslateAnchorTransition) },
+        { "line-width-transition", mbgl::underlying_type(Property::LineWidthTransition) }
     });
 
     const auto it = properties.find(name.c_str());
@@ -670,10 +671,10 @@ optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Conv
         LineRoundLimit,
     };
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "line-cap", static_cast<uint8_t>(Property::LineCap) },
-        { "line-join", static_cast<uint8_t>(Property::LineJoin) },
-        { "line-miter-limit", static_cast<uint8_t>(Property::LineMiterLimit) },
-        { "line-round-limit", static_cast<uint8_t>(Property::LineRoundLimit) }
+        { "line-cap", mbgl::underlying_type(Property::LineCap) },
+        { "line-join", mbgl::underlying_type(Property::LineJoin) },
+        { "line-miter-limit", mbgl::underlying_type(Property::LineMiterLimit) },
+        { "line-round-limit", mbgl::underlying_type(Property::LineRoundLimit) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index 1e2cd748c1..ead2223ea6 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -282,7 +283,7 @@ TransitionOptions RasterLayer::getRasterSaturationTransition() const {
 using namespace conversion;
 
 optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         RasterBrightnessMax,
         RasterBrightnessMin,
         RasterContrast,
@@ -302,22 +303,22 @@ optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Con
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "raster-brightness-max", static_cast<uint8_t>(Property::RasterBrightnessMax) },
-        { "raster-brightness-min", static_cast<uint8_t>(Property::RasterBrightnessMin) },
-        { "raster-contrast", static_cast<uint8_t>(Property::RasterContrast) },
-        { "raster-fade-duration", static_cast<uint8_t>(Property::RasterFadeDuration) },
-        { "raster-hue-rotate", static_cast<uint8_t>(Property::RasterHueRotate) },
-        { "raster-opacity", static_cast<uint8_t>(Property::RasterOpacity) },
-        { "raster-resampling", static_cast<uint8_t>(Property::RasterResampling) },
-        { "raster-saturation", static_cast<uint8_t>(Property::RasterSaturation) },
-        { "raster-brightness-max-transition", static_cast<uint8_t>(Property::RasterBrightnessMaxTransition) },
-        { "raster-brightness-min-transition", static_cast<uint8_t>(Property::RasterBrightnessMinTransition) },
-        { "raster-contrast-transition", static_cast<uint8_t>(Property::RasterContrastTransition) },
-        { "raster-fade-duration-transition", static_cast<uint8_t>(Property::RasterFadeDurationTransition) },
-        { "raster-hue-rotate-transition", static_cast<uint8_t>(Property::RasterHueRotateTransition) },
-        { "raster-opacity-transition", static_cast<uint8_t>(Property::RasterOpacityTransition) },
-        { "raster-resampling-transition", static_cast<uint8_t>(Property::RasterResamplingTransition) },
-        { "raster-saturation-transition", static_cast<uint8_t>(Property::RasterSaturationTransition) }
+        { "raster-brightness-max", mbgl::underlying_type(Property::RasterBrightnessMax) },
+        { "raster-brightness-min", mbgl::underlying_type(Property::RasterBrightnessMin) },
+        { "raster-contrast", mbgl::underlying_type(Property::RasterContrast) },
+        { "raster-fade-duration", mbgl::underlying_type(Property::RasterFadeDuration) },
+        { "raster-hue-rotate", mbgl::underlying_type(Property::RasterHueRotate) },
+        { "raster-opacity", mbgl::underlying_type(Property::RasterOpacity) },
+        { "raster-resampling", mbgl::underlying_type(Property::RasterResampling) },
+        { "raster-saturation", mbgl::underlying_type(Property::RasterSaturation) },
+        { "raster-brightness-max-transition", mbgl::underlying_type(Property::RasterBrightnessMaxTransition) },
+        { "raster-brightness-min-transition", mbgl::underlying_type(Property::RasterBrightnessMinTransition) },
+        { "raster-contrast-transition", mbgl::underlying_type(Property::RasterContrastTransition) },
+        { "raster-fade-duration-transition", mbgl::underlying_type(Property::RasterFadeDurationTransition) },
+        { "raster-hue-rotate-transition", mbgl::underlying_type(Property::RasterHueRotateTransition) },
+        { "raster-opacity-transition", mbgl::underlying_type(Property::RasterOpacityTransition) },
+        { "raster-resampling-transition", mbgl::underlying_type(Property::RasterResamplingTransition) },
+        { "raster-saturation-transition", mbgl::underlying_type(Property::RasterSaturationTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 4b335ead3c..157d8c745f 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -1101,7 +1102,7 @@ TransitionOptions SymbolLayer::getTextTranslateAnchorTransition() const {
 using namespace conversion;
 
 optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         IconColor,
         IconHaloBlur,
         IconHaloColor,
@@ -1133,34 +1134,34 @@ optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Con
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "icon-color", static_cast<uint8_t>(Property::IconColor) },
-        { "icon-halo-blur", static_cast<uint8_t>(Property::IconHaloBlur) },
-        { "icon-halo-color", static_cast<uint8_t>(Property::IconHaloColor) },
-        { "icon-halo-width", static_cast<uint8_t>(Property::IconHaloWidth) },
-        { "icon-opacity", static_cast<uint8_t>(Property::IconOpacity) },
-        { "icon-translate", static_cast<uint8_t>(Property::IconTranslate) },
-        { "icon-translate-anchor", static_cast<uint8_t>(Property::IconTranslateAnchor) },
-        { "text-color", static_cast<uint8_t>(Property::TextColor) },
-        { "text-halo-blur", static_cast<uint8_t>(Property::TextHaloBlur) },
-        { "text-halo-color", static_cast<uint8_t>(Property::TextHaloColor) },
-        { "text-halo-width", static_cast<uint8_t>(Property::TextHaloWidth) },
-        { "text-opacity", static_cast<uint8_t>(Property::TextOpacity) },
-        { "text-translate", static_cast<uint8_t>(Property::TextTranslate) },
-        { "text-translate-anchor", static_cast<uint8_t>(Property::TextTranslateAnchor) },
-        { "icon-color-transition", static_cast<uint8_t>(Property::IconColorTransition) },
-        { "icon-halo-blur-transition", static_cast<uint8_t>(Property::IconHaloBlurTransition) },
-        { "icon-halo-color-transition", static_cast<uint8_t>(Property::IconHaloColorTransition) },
-        { "icon-halo-width-transition", static_cast<uint8_t>(Property::IconHaloWidthTransition) },
-        { "icon-opacity-transition", static_cast<uint8_t>(Property::IconOpacityTransition) },
-        { "icon-translate-transition", static_cast<uint8_t>(Property::IconTranslateTransition) },
-        { "icon-translate-anchor-transition", static_cast<uint8_t>(Property::IconTranslateAnchorTransition) },
-        { "text-color-transition", static_cast<uint8_t>(Property::TextColorTransition) },
-        { "text-halo-blur-transition", static_cast<uint8_t>(Property::TextHaloBlurTransition) },
-        { "text-halo-color-transition", static_cast<uint8_t>(Property::TextHaloColorTransition) },
-        { "text-halo-width-transition", static_cast<uint8_t>(Property::TextHaloWidthTransition) },
-        { "text-opacity-transition", static_cast<uint8_t>(Property::TextOpacityTransition) },
-        { "text-translate-transition", static_cast<uint8_t>(Property::TextTranslateTransition) },
-        { "text-translate-anchor-transition", static_cast<uint8_t>(Property::TextTranslateAnchorTransition) }
+        { "icon-color", mbgl::underlying_type(Property::IconColor) },
+        { "icon-halo-blur", mbgl::underlying_type(Property::IconHaloBlur) },
+        { "icon-halo-color", mbgl::underlying_type(Property::IconHaloColor) },
+        { "icon-halo-width", mbgl::underlying_type(Property::IconHaloWidth) },
+        { "icon-opacity", mbgl::underlying_type(Property::IconOpacity) },
+        { "icon-translate", mbgl::underlying_type(Property::IconTranslate) },
+        { "icon-translate-anchor", mbgl::underlying_type(Property::IconTranslateAnchor) },
+        { "text-color", mbgl::underlying_type(Property::TextColor) },
+        { "text-halo-blur", mbgl::underlying_type(Property::TextHaloBlur) },
+        { "text-halo-color", mbgl::underlying_type(Property::TextHaloColor) },
+        { "text-halo-width", mbgl::underlying_type(Property::TextHaloWidth) },
+        { "text-opacity", mbgl::underlying_type(Property::TextOpacity) },
+        { "text-translate", mbgl::underlying_type(Property::TextTranslate) },
+        { "text-translate-anchor", mbgl::underlying_type(Property::TextTranslateAnchor) },
+        { "icon-color-transition", mbgl::underlying_type(Property::IconColorTransition) },
+        { "icon-halo-blur-transition", mbgl::underlying_type(Property::IconHaloBlurTransition) },
+        { "icon-halo-color-transition", mbgl::underlying_type(Property::IconHaloColorTransition) },
+        { "icon-halo-width-transition", mbgl::underlying_type(Property::IconHaloWidthTransition) },
+        { "icon-opacity-transition", mbgl::underlying_type(Property::IconOpacityTransition) },
+        { "icon-translate-transition", mbgl::underlying_type(Property::IconTranslateTransition) },
+        { "icon-translate-anchor-transition", mbgl::underlying_type(Property::IconTranslateAnchorTransition) },
+        { "text-color-transition", mbgl::underlying_type(Property::TextColorTransition) },
+        { "text-halo-blur-transition", mbgl::underlying_type(Property::TextHaloBlurTransition) },
+        { "text-halo-color-transition", mbgl::underlying_type(Property::TextHaloColorTransition) },
+        { "text-halo-width-transition", mbgl::underlying_type(Property::TextHaloWidthTransition) },
+        { "text-opacity-transition", mbgl::underlying_type(Property::TextOpacityTransition) },
+        { "text-translate-transition", mbgl::underlying_type(Property::TextTranslateTransition) },
+        { "text-translate-anchor-transition", mbgl::underlying_type(Property::TextTranslateAnchorTransition) }
     });
 
     const auto it = properties.find(name.c_str());
@@ -1406,47 +1407,47 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
         TextWritingMode,
     };
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "icon-allow-overlap", static_cast<uint8_t>(Property::IconAllowOverlap) },
-        { "icon-anchor", static_cast<uint8_t>(Property::IconAnchor) },
-        { "icon-ignore-placement", static_cast<uint8_t>(Property::IconIgnorePlacement) },
-        { "icon-image", static_cast<uint8_t>(Property::IconImage) },
-        { "icon-keep-upright", static_cast<uint8_t>(Property::IconKeepUpright) },
-        { "icon-offset", static_cast<uint8_t>(Property::IconOffset) },
-        { "icon-optional", static_cast<uint8_t>(Property::IconOptional) },
-        { "icon-padding", static_cast<uint8_t>(Property::IconPadding) },
-        { "icon-pitch-alignment", static_cast<uint8_t>(Property::IconPitchAlignment) },
-        { "icon-rotate", static_cast<uint8_t>(Property::IconRotate) },
-        { "icon-rotation-alignment", static_cast<uint8_t>(Property::IconRotationAlignment) },
-        { "icon-size", static_cast<uint8_t>(Property::IconSize) },
-        { "icon-text-fit", static_cast<uint8_t>(Property::IconTextFit) },
-        { "icon-text-fit-padding", static_cast<uint8_t>(Property::IconTextFitPadding) },
-        { "symbol-avoid-edges", static_cast<uint8_t>(Property::SymbolAvoidEdges) },
-        { "symbol-placement", static_cast<uint8_t>(Property::SymbolPlacement) },
-        { "symbol-sort-key", static_cast<uint8_t>(Property::SymbolSortKey) },
-        { "symbol-spacing", static_cast<uint8_t>(Property::SymbolSpacing) },
-        { "symbol-z-order", static_cast<uint8_t>(Property::SymbolZOrder) },
-        { "text-allow-overlap", static_cast<uint8_t>(Property::TextAllowOverlap) },
-        { "text-anchor", static_cast<uint8_t>(Property::TextAnchor) },
-        { "text-field", static_cast<uint8_t>(Property::TextField) },
-        { "text-font", static_cast<uint8_t>(Property::TextFont) },
-        { "text-ignore-placement", static_cast<uint8_t>(Property::TextIgnorePlacement) },
-        { "text-justify", static_cast<uint8_t>(Property::TextJustify) },
-        { "text-keep-upright", static_cast<uint8_t>(Property::TextKeepUpright) },
-        { "text-letter-spacing", static_cast<uint8_t>(Property::TextLetterSpacing) },
-        { "text-line-height", static_cast<uint8_t>(Property::TextLineHeight) },
-        { "text-max-angle", static_cast<uint8_t>(Property::TextMaxAngle) },
-        { "text-max-width", static_cast<uint8_t>(Property::TextMaxWidth) },
-        { "text-offset", static_cast<uint8_t>(Property::TextOffset) },
-        { "text-optional", static_cast<uint8_t>(Property::TextOptional) },
-        { "text-padding", static_cast<uint8_t>(Property::TextPadding) },
-        { "text-pitch-alignment", static_cast<uint8_t>(Property::TextPitchAlignment) },
-        { "text-radial-offset", static_cast<uint8_t>(Property::TextRadialOffset) },
-        { "text-rotate", static_cast<uint8_t>(Property::TextRotate) },
-        { "text-rotation-alignment", static_cast<uint8_t>(Property::TextRotationAlignment) },
-        { "text-size", static_cast<uint8_t>(Property::TextSize) },
-        { "text-transform", static_cast<uint8_t>(Property::TextTransform) },
-        { "text-variable-anchor", static_cast<uint8_t>(Property::TextVariableAnchor) },
-        { "text-writing-mode", static_cast<uint8_t>(Property::TextWritingMode) }
+        { "icon-allow-overlap", mbgl::underlying_type(Property::IconAllowOverlap) },
+        { "icon-anchor", mbgl::underlying_type(Property::IconAnchor) },
+        { "icon-ignore-placement", mbgl::underlying_type(Property::IconIgnorePlacement) },
+        { "icon-image", mbgl::underlying_type(Property::IconImage) },
+        { "icon-keep-upright", mbgl::underlying_type(Property::IconKeepUpright) },
+        { "icon-offset", mbgl::underlying_type(Property::IconOffset) },
+        { "icon-optional", mbgl::underlying_type(Property::IconOptional) },
+        { "icon-padding", mbgl::underlying_type(Property::IconPadding) },
+        { "icon-pitch-alignment", mbgl::underlying_type(Property::IconPitchAlignment) },
+        { "icon-rotate", mbgl::underlying_type(Property::IconRotate) },
+        { "icon-rotation-alignment", mbgl::underlying_type(Property::IconRotationAlignment) },
+        { "icon-size", mbgl::underlying_type(Property::IconSize) },
+        { "icon-text-fit", mbgl::underlying_type(Property::IconTextFit) },
+        { "icon-text-fit-padding", mbgl::underlying_type(Property::IconTextFitPadding) },
+        { "symbol-avoid-edges", mbgl::underlying_type(Property::SymbolAvoidEdges) },
+        { "symbol-placement", mbgl::underlying_type(Property::SymbolPlacement) },
+        { "symbol-sort-key", mbgl::underlying_type(Property::SymbolSortKey) },
+        { "symbol-spacing", mbgl::underlying_type(Property::SymbolSpacing) },
+        { "symbol-z-order", mbgl::underlying_type(Property::SymbolZOrder) },
+        { "text-allow-overlap", mbgl::underlying_type(Property::TextAllowOverlap) },
+        { "text-anchor", mbgl::underlying_type(Property::TextAnchor) },
+        { "text-field", mbgl::underlying_type(Property::TextField) },
+        { "text-font", mbgl::underlying_type(Property::TextFont) },
+        { "text-ignore-placement", mbgl::underlying_type(Property::TextIgnorePlacement) },
+        { "text-justify", mbgl::underlying_type(Property::TextJustify) },
+        { "text-keep-upright", mbgl::underlying_type(Property::TextKeepUpright) },
+        { "text-letter-spacing", mbgl::underlying_type(Property::TextLetterSpacing) },
+        { "text-line-height", mbgl::underlying_type(Property::TextLineHeight) },
+        { "text-max-angle", mbgl::underlying_type(Property::TextMaxAngle) },
+        { "text-max-width", mbgl::underlying_type(Property::TextMaxWidth) },
+        { "text-offset", mbgl::underlying_type(Property::TextOffset) },
+        { "text-optional", mbgl::underlying_type(Property::TextOptional) },
+        { "text-padding", mbgl::underlying_type(Property::TextPadding) },
+        { "text-pitch-alignment", mbgl::underlying_type(Property::TextPitchAlignment) },
+        { "text-radial-offset", mbgl::underlying_type(Property::TextRadialOffset) },
+        { "text-rotate", mbgl::underlying_type(Property::TextRotate) },
+        { "text-rotation-alignment", mbgl::underlying_type(Property::TextRotationAlignment) },
+        { "text-size", mbgl::underlying_type(Property::TextSize) },
+        { "text-transform", mbgl::underlying_type(Property::TextTransform) },
+        { "text-variable-anchor", mbgl::underlying_type(Property::TextVariableAnchor) },
+        { "text-writing-mode", mbgl::underlying_type(Property::TextWritingMode) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/light.cpp b/src/mbgl/style/light.cpp
index cc8897acee..b01f4220f2 100644
--- a/src/mbgl/style/light.cpp
+++ b/src/mbgl/style/light.cpp
@@ -8,6 +8,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -34,7 +35,7 @@ Mutable<Light::Impl> Light::mutableImpl() const {
 using namespace conversion;
 
 optional<Error> Light::setProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
         Anchor,
         Color,
         Intensity,
@@ -46,14 +47,14 @@ optional<Error> Light::setProperty(const std::string& name, const Convertible& v
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        { "anchor", static_cast<uint8_t>(Property::Anchor) },
-        { "color", static_cast<uint8_t>(Property::Color) },
-        { "intensity", static_cast<uint8_t>(Property::Intensity) },
-        { "position", static_cast<uint8_t>(Property::Position) },
-        { "anchor-transition", static_cast<uint8_t>(Property::AnchorTransition) },
-        { "color-transition", static_cast<uint8_t>(Property::ColorTransition) },
-        { "intensity-transition", static_cast<uint8_t>(Property::IntensityTransition) },
-        { "position-transition", static_cast<uint8_t>(Property::PositionTransition) }
+        { "anchor", mbgl::underlying_type(Property::Anchor) },
+        { "color", mbgl::underlying_type(Property::Color) },
+        { "intensity", mbgl::underlying_type(Property::Intensity) },
+        { "position", mbgl::underlying_type(Property::Position) },
+        { "anchor-transition", mbgl::underlying_type(Property::AnchorTransition) },
+        { "color-transition", mbgl::underlying_type(Property::ColorTransition) },
+        { "intensity-transition", mbgl::underlying_type(Property::IntensityTransition) },
+        { "position-transition", mbgl::underlying_type(Property::PositionTransition) }
     });
 
     const auto it = properties.find(name.c_str());
diff --git a/src/mbgl/style/light.cpp.ejs b/src/mbgl/style/light.cpp.ejs
index 93e487f7a8..579889ab0d 100644
--- a/src/mbgl/style/light.cpp.ejs
+++ b/src/mbgl/style/light.cpp.ejs
@@ -11,6 +11,7 @@
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <mapbox/eternal.hpp>
 
@@ -37,7 +38,7 @@ Mutable<Light::Impl> Light::mutableImpl() const {
 using namespace conversion;
 
 optional<Error> Light::setProperty(const std::string& name, const Convertible& value) {
-    enum class Property : uint8_t {
+    enum class Property {
 <% for (const property of properties) { -%>
         <%- camelize(property.name) %>,
 <% } -%>
@@ -47,8 +48,8 @@ optional<Error> Light::setProperty(const std::string& name, const Convertible& v
     };
 
     MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
-        <%- properties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n        ') %>,
-        <%- properties.map(p => `{ "${p.name}-transition", static_cast<uint8_t>(Property::${camelize(p.name)}Transition) }`).join(',\n        ') %>
+        <%- properties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n        ') %>,
+        <%- properties.map(p => `{ "${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition) }`).join(',\n        ') %>
     });
 
     const auto it = properties.find(name.c_str());