[core] Fix most identity function with default legacy expression tests

Add handling of default value to the conversion of legacy identity
functions. The color and enum tests still don't pass though.

5 files changed, 63 insertions, 33 deletions

diff --git a/include/mbgl/style/expression/dsl.hpp b/include/mbgl/style/expression/dsl.hpp
index bd94a765e7..dc0f1ab90f 100644
--- a/include/mbgl/style/expression/dsl.hpp
+++ b/include/mbgl/style/expression/dsl.hpp
@@ -31,14 +31,21 @@ std::unique_ptr<Expression> literal(Value value);
 std::unique_ptr<Expression> literal(std::initializer_list<double> value);
 std::unique_ptr<Expression> literal(std::initializer_list<const char *> value);
 
-std::unique_ptr<Expression> assertion(type::Type, std::unique_ptr<Expression>);
-std::unique_ptr<Expression> number(std::unique_ptr<Expression>);
-std::unique_ptr<Expression> string(std::unique_ptr<Expression>);
-std::unique_ptr<Expression> boolean(std::unique_ptr<Expression>);
-
-std::unique_ptr<Expression> toColor(std::unique_ptr<Expression>);
-std::unique_ptr<Expression> toString(std::unique_ptr<Expression>);
-std::unique_ptr<Expression> toFormatted(std::unique_ptr<Expression>);
+std::unique_ptr<Expression> assertion(type::Type, std::unique_ptr<Expression>,
+                                      optional<std::unique_ptr<Expression>> def = {});
+std::unique_ptr<Expression> number(std::unique_ptr<Expression>,
+                                   optional<std::unique_ptr<Expression>> def = {});
+std::unique_ptr<Expression> string(std::unique_ptr<Expression>,
+                                   optional<std::unique_ptr<Expression>> def = {});
+std::unique_ptr<Expression> boolean(std::unique_ptr<Expression>,
+                                    optional<std::unique_ptr<Expression>> def = {});
+
+std::unique_ptr<Expression> toColor(std::unique_ptr<Expression>,
+                                    optional<std::unique_ptr<Expression>> def = {});
+std::unique_ptr<Expression> toString(std::unique_ptr<Expression>,
+                                     optional<std::unique_ptr<Expression>> def = {});
+std::unique_ptr<Expression> toFormatted(std::unique_ptr<Expression>,
+                                        optional<std::unique_ptr<Expression>> def = {});
     
 std::unique_ptr<Expression> get(const char* value);
 std::unique_ptr<Expression> get(std::unique_ptr<Expression>);
diff --git a/platform/node/test/ignores.json b/platform/node/test/ignores.json
index 287211f388..d7cbe0782e 100644
--- a/platform/node/test/ignores.json
+++ b/platform/node/test/ignores.json
@@ -21,12 +21,8 @@
   "expression-tests/legacy/exponential/color-lab": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/exponential/composite-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/exponential/number-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
-  "expression-tests/legacy/identity/array-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
-  "expression-tests/legacy/identity/boolean-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/identity/color-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/identity/enum-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
-  "expression-tests/legacy/identity/number-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
-  "expression-tests/legacy/identity/string-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/interval/array": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/interval/array-default": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
   "expression-tests/legacy/interval/color": "https://github.com/mapbox/mapbox-gl-native/issues/12747",
diff --git a/src/mbgl/style/conversion/function.cpp b/src/mbgl/style/conversion/function.cpp
index fdf52c36db..179ad0e437 100644
--- a/src/mbgl/style/conversion/function.cpp
+++ b/src/mbgl/style/conversion/function.cpp
@@ -660,6 +660,11 @@ optional<std::unique_ptr<Expression>> convertFunctionToExpression(type::Type typ
         }
     }
 
+    optional<std::unique_ptr<Expression>> defaultExpr;
+    if (objectMember(value, "default")) {
+        defaultExpr = convertLiteral(type, *objectMember(value, "default"), err);
+    }
+
     if (!objectMember(value, "property")) {
         // Camera function.
         switch (functionType) {
@@ -688,22 +693,22 @@ optional<std::unique_ptr<Expression>> convertFunctionToExpression(type::Type typ
     if (functionType == FunctionType::Identity) {
         return type.match(
             [&] (const type::StringType&) -> optional<std::unique_ptr<Expression>> {
-                return string(get(literal(*property)));
+                return string(get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const type::NumberType&) -> optional<std::unique_ptr<Expression>> {
-                return number(get(literal(*property)));
+                return number(get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const type::BooleanType&) -> optional<std::unique_ptr<Expression>> {
-                return boolean(get(literal(*property)));
+                return boolean(get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const type::ColorType&) -> optional<std::unique_ptr<Expression>> {
-                return toColor(get(literal(*property)));
+                return toColor(get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const type::Array& array) -> optional<std::unique_ptr<Expression>> {
-                return assertion(array, get(literal(*property)));
+                return assertion(array, get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const type::FormattedType&) -> optional<std::unique_ptr<Expression>> {
-                return format(get(literal(*property)));
+                return toFormatted(get(literal(*property)), std::move(defaultExpr));
             },
             [&] (const auto&) -> optional<std::unique_ptr<Expression>>  {
                 assert(false); // No properties use this type.
diff --git a/src/mbgl/style/expression/dsl.cpp b/src/mbgl/style/expression/dsl.cpp
index b4fd8fa551..d1d8dea799 100644
--- a/src/mbgl/style/expression/dsl.cpp
+++ b/src/mbgl/style/expression/dsl.cpp
@@ -54,32 +54,54 @@ std::unique_ptr<Expression> literal(std::initializer_list<const char *> value) {
     return literal(values);
 }
 
-std::unique_ptr<Expression> assertion(type::Type type, std::unique_ptr<Expression> value) {
-    return std::make_unique<Assertion>(type, vec(std::move(value)));
+std::unique_ptr<Expression> assertion(type::Type type,
+                                      std::unique_ptr<Expression> value,
+                                      optional<std::unique_ptr<Expression>> def) {
+    std::vector<std::unique_ptr<Expression>> v  = vec(std::move(value));
+    if (def) {
+        v.push_back(std::move(*def));
+    }
+    return std::make_unique<Assertion>(type, std::move(v));
+}
+
+std::unique_ptr<Expression> number(std::unique_ptr<Expression> value,
+                                   optional<std::unique_ptr<Expression>> def) {
+    return assertion(type::Number, std::move(value), std::move(def));
 }
 
-std::unique_ptr<Expression> number(std::unique_ptr<Expression> value) {
-    return assertion(type::Number, std::move(value));
+std::unique_ptr<Expression> string(std::unique_ptr<Expression> value,
+                                   optional<std::unique_ptr<Expression>> def) {
+    return assertion(type::String, std::move(value), std::move(def));
 }
 
-std::unique_ptr<Expression> string(std::unique_ptr<Expression> value) {
-    return assertion(type::String, std::move(value));
+std::unique_ptr<Expression> boolean(std::unique_ptr<Expression> value,
+                                    optional<std::unique_ptr<Expression>> def) {
+    return assertion(type::Boolean, std::move(value), std::move(def));
 }
 
-std::unique_ptr<Expression> boolean(std::unique_ptr<Expression> value) {
-    return assertion(type::Boolean, std::move(value));
+std::unique_ptr<Expression> coercion(type::Type type,
+                                     std::unique_ptr<Expression> value,
+                                     optional<std::unique_ptr<Expression>> def) {
+    std::vector<std::unique_ptr<Expression>> v = vec(std::move(value));
+    if (def) {
+        v.push_back(std::move(*def));
+    }
+    return std::make_unique<Coercion>(type, std::move(v));
 }
 
-std::unique_ptr<Expression> toColor(std::unique_ptr<Expression> value) {
-    return std::make_unique<Coercion>(type::Color, vec(std::move(value)));
+std::unique_ptr<Expression> toColor(std::unique_ptr<Expression> value,
+                                    optional<std::unique_ptr<Expression>> def) {
+    return coercion(type::Color, std::move(value), std::move(def));
 }
 
-std::unique_ptr<Expression> toString(std::unique_ptr<Expression> value) {
-    return std::make_unique<Coercion>(type::String, vec(std::move(value)));
+std::unique_ptr<Expression> toString(std::unique_ptr<Expression> value,
+                                     optional<std::unique_ptr<Expression>> def) {
+    return coercion(type::String, std::move(value), std::move(def));
 }
 
-std::unique_ptr<Expression> toFormatted(std::unique_ptr<Expression> value) {
-    return std::make_unique<Coercion>(type::Formatted, vec(std::move(value)));
+std::unique_ptr<Expression> toFormatted(std::unique_ptr<Expression> value,
+                                        optional<std::unique_ptr<Expression>> def) {
+    return coercion(type::Formatted, std::move(value), std::move(def));
 }
     
 std::unique_ptr<Expression> get(const char* value) {
diff --git a/test/style/conversion/function.test.cpp b/test/style/conversion/function.test.cpp
index 93a9a7e608..5c96e5124b 100644
--- a/test/style/conversion/function.test.cpp
+++ b/test/style/conversion/function.test.cpp
@@ -108,5 +108,5 @@ TEST(StyleConversion, FormattedIdentityFunction) {
     auto fn1 = parseFunction(R"({ "property": "name", "type": "identity" })");
     ASSERT_TRUE(bool(fn1));
     ASSERT_TRUE(fn1->isExpression());
-    ASSERT_EQ(fn1->asExpression().getExpression(), *format(get(literal("name"))));
+    ASSERT_EQ(fn1->asExpression().getExpression().serialize(), format(get(literal("name")))->serialize());
 }