6 files changed, 61 insertions, 11 deletions
diff --git a/src/mbgl/style/conversion/constant.cpp b/src/mbgl/style/conversion/constant.cpp
index 0fcaab433b..0ed5fad425 100644
--- a/src/mbgl/style/conversion/constant.cpp
+++ b/src/mbgl/style/conversion/constant.cpp
@@ -168,6 +168,24 @@ optional<std::vector<std::string>> Converter<std::vector<std::string>>::operator
     return result;
 }
 
+optional<RadialOffsetType> Converter<RadialOffsetType>::operator()(const Convertible& value, Error& error) const {
+    Converter<std::vector<float>> arrayConverter;
+    if (auto val = arrayConverter(value, error)) {
+        RadialOffsetType result = std::move(*val);
+        return result;
+    }
+
+    Converter<float> numberConverter;
+    if (auto val = numberConverter(value, error)) {
+        RadialOffsetType result(2, *val);
+        return result;
+    }
+
+    error.message = "value must be an array of numbers or a number";
+
+    return nullopt;
+}
+
 } // namespace conversion
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/conversion/function.cpp b/src/mbgl/style/conversion/function.cpp
index 086bc4e277..ade5a5dc5e 100644
--- a/src/mbgl/style/conversion/function.cpp
+++ b/src/mbgl/style/conversion/function.cpp
@@ -153,6 +153,10 @@ template optional<PropertyExpression<TranslateAnchorType>>
 template optional<PropertyExpression<Formatted>>
     convertFunctionToExpression<Formatted>(const Convertible&, Error&, bool);
 
+template optional<PropertyExpression<RadialOffsetType>>
+    convertFunctionToExpression<RadialOffsetType>(const Convertible&, Error&, bool);
+
+
 // Ad-hoc Converters for double and int64_t. We should replace float with double wholesale,
 // and promote the int64_t Converter to general use (and it should check that the input is
 // an integer).
diff --git a/src/mbgl/style/conversion/property_value.cpp b/src/mbgl/style/conversion/property_value.cpp
index 6e1d747324..91e61ec5cb 100644
--- a/src/mbgl/style/conversion/property_value.cpp
+++ b/src/mbgl/style/conversion/property_value.cpp
@@ -80,6 +80,7 @@ template optional<PropertyValue<TextJustifyType>> Converter<PropertyValue<TextJu
 template optional<PropertyValue<TextTransformType>> Converter<PropertyValue<TextTransformType>>::operator()(conversion::Convertible const&, conversion::Error&, bool, bool) const;
 template optional<PropertyValue<TranslateAnchorType>> Converter<PropertyValue<TranslateAnchorType>>::operator()(conversion::Convertible const&, conversion::Error&, bool, bool) const;
 template optional<PropertyValue<mbgl::style::expression::Formatted>> Converter<PropertyValue<mbgl::style::expression::Formatted>>::operator()(conversion::Convertible const&, conversion::Error&, bool, bool) const;
+template optional<PropertyValue<RadialOffsetType>> Converter<PropertyValue<RadialOffsetType>>::operator()(conversion::Convertible const&, conversion::Error&, bool, bool) const;
 
 } // namespace conversion
 } // namespace style
diff --git a/src/mbgl/style/expression/value.cpp b/src/mbgl/style/expression/value.cpp
index 7e11efaa09..6fce98e4d6 100644
--- a/src/mbgl/style/expression/value.cpp
+++ b/src/mbgl/style/expression/value.cpp
@@ -276,6 +276,22 @@ optional<Position> ValueConverter<Position>::fromExpressionValue(const Value& v)
     return pos ? optional<Position>(Position(*pos)) : optional<Position>();
 }
 
+Value ValueConverter<RadialOffsetType>::toExpressionValue(const mbgl::style::RadialOffsetType& value) {
+    return ValueConverter<std::vector<float>>::toExpressionValue(value);
+}
+
+optional<RadialOffsetType> ValueConverter<RadialOffsetType>::fromExpressionValue(const Value& v) {
+    if (auto val = ValueConverter<std::vector<float>>::fromExpressionValue(v)) {
+        RadialOffsetType result(std::move(*val));
+        return result;
+    }
+    if (auto val = ValueConverter<float>::fromExpressionValue(v)) {
+        RadialOffsetType result(2, *val);
+        return result;
+    }
+    return nullopt;
+}
+
 template <typename T>
 Value ValueConverter<T, std::enable_if_t< std::is_enum<T>::value >>::toExpressionValue(const T& value) {
     return std::string(Enum<T>::toString(value));
@@ -374,6 +390,10 @@ template struct ValueConverter<HillshadeIlluminationAnchorType>;
 template type::Type valueTypeToExpressionType<LightAnchorType>();
 template struct ValueConverter<LightAnchorType>;
 
+template<> type::Type valueTypeToExpressionType<RadialOffsetType>() {
+    return valueTypeToExpressionType<std::vector<float>>();
+}
+
 } // namespace expression
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 6748fbd4aa..c5a32acd12 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -605,15 +605,15 @@ void SymbolLayer::setTextPitchAlignment(const PropertyValue<AlignmentType>& valu
     baseImpl = std::move(impl_);
     observer->onLayerChanged(*this);
 }
-PropertyValue<float> SymbolLayer::getDefaultTextRadialOffset() {
+PropertyValue<RadialOffsetType> SymbolLayer::getDefaultTextRadialOffset() {
     return TextRadialOffset::defaultValue();
 }
 
-const PropertyValue<float>& SymbolLayer::getTextRadialOffset() const {
+const PropertyValue<RadialOffsetType>& SymbolLayer::getTextRadialOffset() const {
     return impl().layout.get<TextRadialOffset>();
 }
 
-void SymbolLayer::setTextRadialOffset(const PropertyValue<float>& value) {
+void SymbolLayer::setTextRadialOffset(const PropertyValue<RadialOffsetType>& value) {
     if (value == getTextRadialOffset())
         return;
     auto impl_ = mutableImpl();
@@ -1606,7 +1606,7 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
         
     }
     
-    if (property == Property::IconRotate || property == Property::IconSize || property == Property::SymbolSortKey || property == Property::TextLetterSpacing || property == Property::TextMaxWidth || property == Property::TextRadialOffset || property == Property::TextRotate || property == Property::TextSize) {
+    if (property == Property::IconRotate || property == Property::IconSize || property == Property::SymbolSortKey || property == Property::TextLetterSpacing || property == Property::TextMaxWidth || property == Property::TextRotate || property == Property::TextSize) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
@@ -1638,11 +1638,6 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
             return nullopt;
         }
         
-        if (property == Property::TextRadialOffset) {
-            setTextRadialOffset(*typedValue);
-            return nullopt;
-        }
-        
         if (property == Property::TextRotate) {
             setTextRotate(*typedValue);
             return nullopt;
@@ -1739,6 +1734,18 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
         
     }
     
+    if (property == Property::TextRadialOffset) {
+        Error error;
+        optional<PropertyValue<RadialOffsetType>> typedValue = convert<PropertyValue<RadialOffsetType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+        
+        setTextRadialOffset(*typedValue);
+        return nullopt;
+        
+    }
+    
     if (property == Property::TextTransform) {
         Error error;
         optional<PropertyValue<TextTransformType>> typedValue = convert<PropertyValue<TextTransformType>>(value, error, true, false);
diff --git a/src/mbgl/style/layers/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp
index 0c2bcd2661..4215819abe 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.hpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.hpp
@@ -184,9 +184,9 @@ struct TextPitchAlignment : LayoutProperty<AlignmentType> {
     static AlignmentType defaultValue() { return AlignmentType::Auto; }
 };
 
-struct TextRadialOffset : DataDrivenLayoutProperty<float> {
+struct TextRadialOffset : DataDrivenLayoutProperty<RadialOffsetType> {
     static constexpr const char *name() { return "text-radial-offset"; }
-    static float defaultValue() { return 0; }
+    static RadialOffsetType defaultValue() { return { 0, 0 }; }
 };
 
 struct TextRotate : DataDrivenLayoutProperty<float> {