[core] Implement image expression (#15877)

* [core] Bump gl-js version
* [core] Implement image expression
* [core] Use new image expression
* [core] Coerce image expression to / from string
* [core] Serialize evaluated image
* [core] Pass available images to layout
* [core] Pass images to evaluation context
* [core] Set available flag value based on image availability
* [core] Allow image coercion to boolean to indicate image availability
* [core] Coalesce image expression
* [core] Add image expression to next build system
* [core] Align serialization format and evaluated type with gl-js
* [core] Add images to expression evaluation method
* [core] Add support for Image expression to expression test runner
* [core] Unskip image expression tests
* [core] Update unit tests
* [core] Use image expression in annotation manager
* [core] Add string to ImageExpression conversion
* [core] Add image expression to expression dsl
* [core] Convert tokens for implicitly created Image literal
* [core] Fix clang format
* [core] Split generated style code lines that are over 120 characters
* [core] Add unit test for image expression equality
* [core] Add image property expression evaluation unit test
* [core] Unskip image expression render test
* [core] Skip 'in' expression tests
* [core] Ignore fill-pattern/update-feature-state render test
* [core] Rename Image::serialize to Image::toValue

1 files changed, 40 insertions, 26 deletions

diff --git a/src/mbgl/style/conversion/function.cpp b/src/mbgl/style/conversion/function.cpp
index 646c1983a2..4b3b8f6c6a 100644
--- a/src/mbgl/style/conversion/function.cpp
+++ b/src/mbgl/style/conversion/function.cpp
@@ -1,13 +1,14 @@
 #include <mbgl/style/conversion/function.hpp>
 #include <mbgl/style/conversion/position.hpp>
 #include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/style/expression/case.hpp>
 #include <mbgl/style/expression/dsl.hpp>
 #include <mbgl/style/expression/dsl_impl.hpp>
-#include <mbgl/style/expression/step.hpp>
+#include <mbgl/style/expression/format_expression.hpp>
+#include <mbgl/style/expression/image_expression.hpp>
 #include <mbgl/style/expression/interpolate.hpp>
 #include <mbgl/style/expression/match.hpp>
-#include <mbgl/style/expression/case.hpp>
-#include <mbgl/style/expression/format_expression.hpp>
+#include <mbgl/style/expression/step.hpp>
 #include <mbgl/util/string.hpp>
 
 #include <cassert>
@@ -46,6 +47,10 @@ std::unique_ptr<Expression> convertTokenStringToFormatExpression(const std::stri
     return std::make_unique<FormatExpression>(sections);
 }
 
+std::unique_ptr<Expression> convertTokenStringToImageExpression(const std::string& source) {
+    return std::make_unique<ImageExpression>(convertTokenStringToExpression(source));
+}
+
 std::unique_ptr<Expression> convertTokenStringToExpression(const std::string& source) {
     std::vector<std::unique_ptr<Expression>> inputs;
 
@@ -149,11 +154,11 @@ template optional<PropertyExpression<TextTransformType>>
     convertFunctionToExpression<TextTransformType>(const Convertible&, Error&, bool);
 template optional<PropertyExpression<TranslateAnchorType>>
     convertFunctionToExpression<TranslateAnchorType>(const Convertible&, Error&, bool);
-    
 template optional<PropertyExpression<Formatted>>
     convertFunctionToExpression<Formatted>(const Convertible&, Error&, bool);
 template optional<PropertyExpression<std::vector<TextWritingModeType>>>
     convertFunctionToExpression<std::vector<TextWritingModeType>>(const Convertible&, Error&, bool);
+template optional<PropertyExpression<Image>> convertFunctionToExpression<Image>(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
@@ -207,35 +212,35 @@ static bool interpolatable(type::Type type) {
 
 static optional<std::unique_ptr<Expression>> convertLiteral(type::Type type, const Convertible& value, Error& error, bool convertTokens = false) {
     return type.match(
-        [&] (const type::NumberType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::NumberType&) -> optional<std::unique_ptr<Expression>> {
             auto result = convert<float>(value, error);
             if (!result) {
                 return nullopt;
             }
             return literal(double(*result));
         },
-        [&] (const type::BooleanType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::BooleanType&) -> optional<std::unique_ptr<Expression>> {
             auto result = convert<bool>(value, error);
             if (!result) {
                 return nullopt;
             }
             return literal(*result);
         },
-        [&] (const type::StringType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::StringType&) -> optional<std::unique_ptr<Expression>> {
             auto result = convert<std::string>(value, error);
             if (!result) {
                 return nullopt;
             }
             return convertTokens ? convertTokenStringToExpression(*result) : literal(*result);
         },
-        [&] (const type::ColorType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::ColorType&) -> optional<std::unique_ptr<Expression>> {
             auto result = convert<Color>(value, error);
             if (!result) {
                 return nullopt;
             }
             return literal(*result);
         },
-        [&] (const type::Array& array) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::Array& array) -> optional<std::unique_ptr<Expression>> {
             if (!isArray(value)) {
                 error.message = "value must be an array";
                 return nullopt;
@@ -277,27 +282,27 @@ static optional<std::unique_ptr<Expression>> convertLiteral(type::Type type, con
                 }
             );
         },
-        [&] (const type::NullType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::NullType&) -> optional<std::unique_ptr<Expression>> {
             assert(false); // No properties use this type.
             return nullopt;
         },
-        [&] (const type::ObjectType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::ObjectType&) -> optional<std::unique_ptr<Expression>> {
             assert(false); // No properties use this type.
             return nullopt;
         },
-        [&] (const type::ErrorType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::ErrorType&) -> optional<std::unique_ptr<Expression>> {
             assert(false); // No properties use this type.
             return nullopt;
         },
-        [&] (const type::ValueType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::ValueType&) -> optional<std::unique_ptr<Expression>> {
             assert(false); // No properties use this type.
             return nullopt;
         },
-        [&] (const type::CollatorType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::CollatorType&) -> optional<std::unique_ptr<Expression>> {
             assert(false); // No properties use this type.
             return nullopt;
         },
-        [&] (const type::FormattedType&) -> optional<std::unique_ptr<Expression>> {
+        [&](const type::FormattedType&) -> optional<std::unique_ptr<Expression>> {
             auto result = convert<std::string>(value, error);
             if (!result) {
                 return nullopt;
@@ -305,8 +310,15 @@ static optional<std::unique_ptr<Expression>> convertLiteral(type::Type type, con
             return convertTokens ?
                 convertTokenStringToFormatExpression(*result) :
                 literal(Formatted(result->c_str()));
-        }
-    );
+        },
+        [&](const type::ImageType&) -> optional<std::unique_ptr<Expression>> {
+            auto result = convert<std::string>(value, error);
+            if (!result) {
+                return nullopt;
+            }
+            return convertTokens ? std::make_unique<ImageExpression>(convertTokenStringToImageExpression(*result))
+                                 : literal(Image(result->c_str()));
+        });
 }
 
 static optional<std::map<double, std::unique_ptr<Expression>>> convertStops(type::Type type,
@@ -749,29 +761,31 @@ optional<std::unique_ptr<Expression>> convertFunctionToExpression(type::Type typ
 
     if (functionType == FunctionType::Identity) {
         return type.match(
-            [&] (const type::StringType&) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::StringType&) -> optional<std::unique_ptr<Expression>> {
                 return string(get(literal(*property)), defaultExpr());
             },
-            [&] (const type::NumberType&) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::NumberType&) -> optional<std::unique_ptr<Expression>> {
                 return number(get(literal(*property)), defaultExpr());
             },
-            [&] (const type::BooleanType&) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::BooleanType&) -> optional<std::unique_ptr<Expression>> {
                 return boolean(get(literal(*property)), defaultExpr());
             },
-            [&] (const type::ColorType&) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::ColorType&) -> optional<std::unique_ptr<Expression>> {
                 return toColor(get(literal(*property)), defaultExpr());
             },
-            [&] (const type::Array& array) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::Array& array) -> optional<std::unique_ptr<Expression>> {
                 return assertion(array, get(literal(*property)), defaultExpr());
             },
-            [&] (const type::FormattedType&) -> optional<std::unique_ptr<Expression>> {
+            [&](const type::FormattedType&) -> optional<std::unique_ptr<Expression>> {
                 return toFormatted(get(literal(*property)), defaultExpr());
             },
-            [&] (const auto&) -> optional<std::unique_ptr<Expression>>  {
+            [&](const type::ImageType&) -> optional<std::unique_ptr<Expression>> {
+                return toImage(get(literal(*property)), defaultExpr());
+            },
+            [&](const auto&) -> optional<std::unique_ptr<Expression>> {
                 assert(false); // No properties use this type.
                 return nullopt;
-            }
-        );
+            });
     }
 
     auto stopsValue = objectMember(value, "stops");