1 files changed, 23 insertions, 10 deletions
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index 8880d28fb1..07ed201c99 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -4,10 +4,12 @@
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/constant.hpp>
 #include <mbgl/style/conversion/function.hpp>
-#include <mbgl/style/conversion/expression.hpp>
 #include <mbgl/style/expression/is_expression.hpp>
 #include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/expression/find_zoom_curve.hpp>
+#include <mbgl/style/expression/literal.hpp>
+#include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/parsing_context.hpp>
 
 #include <unordered_set>
 
@@ -20,24 +22,35 @@ template <class T>
 struct Converter<DataDrivenPropertyValue<T>> {
 
     optional<DataDrivenPropertyValue<T>> operator()(const Convertible& value, Error& error) const {
+        using namespace mbgl::style::expression;
+        
         if (isUndefined(value)) {
             return DataDrivenPropertyValue<T>();
-        } else if (expression::isExpression(value)) {
-            optional<std::unique_ptr<Expression>> expression = convert<std::unique_ptr<Expression>>(
-                value,
-                error,
-                valueTypeToExpressionType<T>());
-            
+        } else if (isExpression(value)) {
+            ParsingContext ctx(valueTypeToExpressionType<T>());
+            ParseResult expression = ctx.parseLayerPropertyExpression(value);
             if (!expression) {
+                error = { ctx.getCombinedErrors() };
                 return {};
             }
             
-            if (isFeatureConstant(**expression)) {
+            bool featureConstant = isFeatureConstant(**expression);
+            bool zoomConstant = isZoomConstant(**expression);
+            
+            if (featureConstant && !zoomConstant) {
                 return DataDrivenPropertyValue<T>(CameraFunction<T>(std::move(*expression)));
-            } else if (isZoomConstant(**expression)) {
+            } else if (!featureConstant && zoomConstant) {
                 return DataDrivenPropertyValue<T>(SourceFunction<T>(std::move(*expression)));
-            } else {
+            } else if (!featureConstant && !zoomConstant) {
                 return DataDrivenPropertyValue<T>(CompositeFunction<T>(std::move(*expression)));
+            } else {
+                auto literal = dynamic_cast<Literal*>(expression->get());
+                assert(literal);
+                optional<T> constant = fromExpressionValue<T>(literal->getValue());
+                if (!constant) {
+                    return {};
+                }
+                return DataDrivenPropertyValue<T>(*constant);
             }
         } else if (!isObject(value)) {
             optional<T> constant = convert<T>(value, error);