1 files changed, 26 insertions, 14 deletions
diff --git a/src/mbgl/style/expression/parsing_context.cpp b/src/mbgl/style/expression/parsing_context.cpp
index 29d04d96a2..0373b9721f 100644
--- a/src/mbgl/style/expression/parsing_context.cpp
+++ b/src/mbgl/style/expression/parsing_context.cpp
@@ -21,6 +21,7 @@
 #include <mbgl/style/expression/step.hpp>
 
 #include <mbgl/style/expression/find_zoom_curve.hpp>
+#include <mbgl/style/expression/dsl.hpp>
 
 #include <mbgl/style/conversion/get_json_type.hpp>
 #include <mbgl/style/conversion_impl.hpp>
@@ -76,7 +77,7 @@ using namespace mbgl::style::conversion;
 ParseResult ParsingContext::parse(const Convertible& value,
                                   std::size_t index_,
                                   optional<type::Type> expected_,
-                                  TypeAnnotationOption typeAnnotationOption) {
+                                  optional<TypeAnnotationOption> typeAnnotationOption) {
     ParsingContext child(key + "[" + util::toString(index_) + "]",
                          errors,
                          std::move(expected_),
@@ -118,14 +119,16 @@ const ExpressionRegistry& getExpressionRegistry() {
         {"object", Assertion::parse},
         {"step", Step::parse},
         {"string", Assertion::parse},
+        {"to-boolean", Coercion::parse},
         {"to-color", Coercion::parse},
         {"to-number", Coercion::parse},
+        {"to-string", Coercion::parse},
         {"var", Var::parse}
     }};
     return registry;
 }
 
-ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption typeAnnotationOption) {
+ParseResult ParsingContext::parse(const Convertible& value, optional<TypeAnnotationOption> typeAnnotationOption) {
     ParseResult parsed;
     
     if (isArray(value)) {
@@ -161,22 +164,27 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
         return parsed;
     }
 
-    auto array = [&](std::unique_ptr<Expression> expression) {
-        std::vector<std::unique_ptr<Expression>> args;
-        args.push_back(std::move(expression));
-        return args;
+    auto annotate = [] (std::unique_ptr<Expression> expression, type::Type type, TypeAnnotationOption typeAnnotation) -> std::unique_ptr<Expression> {
+        switch (typeAnnotation) {
+        case TypeAnnotationOption::assert:
+            return std::make_unique<Assertion>(type, dsl::vec(std::move(expression)));
+        case TypeAnnotationOption::coerce:
+            return std::make_unique<Coercion>(type, dsl::vec(std::move(expression)));
+        case TypeAnnotationOption::omit:
+            return expression;
+        }
+
+        // Not reachable, but placate GCC.
+        assert(false);
+        return expression;
     };
 
     if (expected) {
         const type::Type actual = (*parsed)->getType();
         if ((*expected == type::String || *expected == type::Number || *expected == type::Boolean || *expected == type::Object || expected->is<type::Array>()) && actual == type::Value) {
-            if (typeAnnotationOption == includeTypeAnnotations) {
-                parsed = { std::make_unique<Assertion>(*expected, array(std::move(*parsed))) };
-            }
+            parsed = { annotate(std::move(*parsed), *expected, typeAnnotationOption.value_or(TypeAnnotationOption::assert)) };
         } else if (*expected == type::Color && (actual == type::Value || actual == type::String)) {
-            if (typeAnnotationOption == includeTypeAnnotations) {
-                parsed = { std::make_unique<Coercion>(*expected, array(std::move(*parsed))) };
-            }
+            parsed = { annotate(std::move(*parsed), *expected, typeAnnotationOption.value_or(TypeAnnotationOption::coerce)) };
         } else {
             checkType((*parsed)->getType());
             if (errors->size() > 0) {
@@ -212,11 +220,15 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
     return parsed;
 }
 
-ParseResult ParsingContext::parseExpression(const Convertible& value, TypeAnnotationOption typeAnnotationOption) {
+ParseResult ParsingContext::parseExpression(const Convertible& value, optional<TypeAnnotationOption> typeAnnotationOption) {
     return parse(value, typeAnnotationOption);
 }
 
-ParseResult ParsingContext::parseLayerPropertyExpression(const Convertible& value, TypeAnnotationOption typeAnnotationOption) {
+ParseResult ParsingContext::parseLayerPropertyExpression(const Convertible& value) {
+    optional<TypeAnnotationOption> typeAnnotationOption;
+    if (expected && *expected == type::String) {
+        typeAnnotationOption = TypeAnnotationOption::coerce;
+    }
     ParseResult parsed = parse(value, typeAnnotationOption);
     if (parsed && !isZoomConstant(**parsed)) {
         optional<variant<const Interpolate*, const Step*, ParsingError>> zoomCurve = findZoomCurve(parsed->get());