Support Feature-state expressions

21 files changed, 81 insertions, 58 deletions

diff --git a/include/mbgl/style/color_ramp_property_value.hpp b/include/mbgl/style/color_ramp_property_value.hpp
index bc5639c89..7a3327004 100644
--- a/include/mbgl/style/color_ramp_property_value.hpp
+++ b/include/mbgl/style/color_ramp_property_value.hpp
@@ -34,7 +34,7 @@ public:
     Color evaluate(const Evaluator&, TimePoint = {}) const { return {}; }
 
     Color evaluate(double rampEvaluationParameter) const {
-        const auto result = value->evaluate(expression::EvaluationContext({}, nullptr, {rampEvaluationParameter}));
+        const auto result = value->evaluate(expression::EvaluationContext({}, nullptr, optional<PropertyMap>{}, {rampEvaluationParameter}));
         return *expression::fromExpressionValue<Color>(*result);
     }
 
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index ce02c4114..91ad0e74b 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -26,16 +26,20 @@ public:
 class EvaluationContext {
 public:
     EvaluationContext(float zoom_) : zoom(zoom_), feature(nullptr) {}
-    EvaluationContext(GeometryTileFeature const * feature_) : zoom(optional<float>()), feature(feature_) {}
-    EvaluationContext(float zoom_, GeometryTileFeature const * feature_) :
-        zoom(zoom_), feature(feature_)
+    EvaluationContext(GeometryTileFeature const * feature_, optional<PropertyMap> featureState_) : zoom(optional<float>()), feature(feature_), featureState(std::move(featureState_)) {}
+    EvaluationContext(float zoom_, GeometryTileFeature const * feature_, optional<PropertyMap> featureState_) :
+        zoom(zoom_), feature(feature_), featureState(std::move(featureState_))
     {}
-    EvaluationContext(optional<float> zoom_, GeometryTileFeature const * feature_, optional<double> colorRampParameter_) :
-        zoom(std::move(zoom_)), feature(feature_), colorRampParameter(std::move(colorRampParameter_))
+    EvaluationContext(optional<float> zoom_, GeometryTileFeature const * feature_, optional<PropertyMap> featureState_, optional<double> colorRampParameter_) :
+        zoom(std::move(zoom_)),
+        feature(feature_),
+        featureState(std::move(featureState_)),
+        colorRampParameter(std::move(colorRampParameter_))
     {}
     
     optional<float> zoom;
     GeometryTileFeature const * feature;
+    optional<PropertyMap> featureState;
     optional<double> colorRampParameter;
 };
 
@@ -150,7 +154,7 @@ public:
     Kind getKind() const { return kind; };
     type::Type getType() const { return type; };
     
-    EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<double> colorRampParameter) const;
+    EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<PropertyMap> featureState, optional<double> colorRampParameter) const;
 
     /**
      * Statically analyze the expression, attempting to enumerate possible outputs. Returns
diff --git a/include/mbgl/style/expression/is_constant.hpp b/include/mbgl/style/expression/is_constant.hpp
index bd758977d..0ac0487c6 100644
--- a/include/mbgl/style/expression/is_constant.hpp
+++ b/include/mbgl/style/expression/is_constant.hpp
@@ -29,7 +29,7 @@ bool isGlobalPropertyConstant(const Expression& expression, const T& properties)
 
 bool isFeatureConstant(const Expression& expression);
 bool isZoomConstant(const Expression& e);
-
+bool isFeatureStateConstant(const Expression& e);
 
 } // namespace expression
 } // namespace style
diff --git a/include/mbgl/style/property_expression.hpp b/include/mbgl/style/property_expression.hpp
index b198de02b..1919c3b3d 100644
--- a/include/mbgl/style/property_expression.hpp
+++ b/include/mbgl/style/property_expression.hpp
@@ -23,11 +23,12 @@ public:
 
     bool isZoomConstant() const { return expression::isZoomConstant(*expression); }
     bool isFeatureConstant() const { return expression::isFeatureConstant(*expression); }
+    bool isFeatureStateConstant() const { return expression::isFeatureStateConstant(*expression); }
 
     T evaluate(float zoom) const {
         assert(!expression::isZoomConstant(*expression));
         assert(expression::isFeatureConstant(*expression));
-        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext(zoom, nullptr));
+        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext(zoom, nullptr, {}));
         if (result) {
             const optional<T> typed = expression::fromExpressionValue<T>(*result);
             return typed ? *typed : defaultValue ? *defaultValue : T();
@@ -36,10 +37,10 @@ public:
     }
 
     template <class Feature>
-    T evaluate(const Feature& feature, T finalDefaultValue) const {
+    T evaluate(const Feature& feature, optional<PropertyMap> featureState, T finalDefaultValue) const {
         assert(expression::isZoomConstant(*expression));
         assert(!expression::isFeatureConstant(*expression));
-        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext(&feature));
+        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext(&feature, featureState));
         if (result) {
             const optional<T> typed = expression::fromExpressionValue<T>(*result);
             return typed ? *typed : defaultValue ? *defaultValue : finalDefaultValue;
@@ -48,9 +49,9 @@ public:
     }
 
     template <class Feature>
-    T evaluate(float zoom, const Feature& feature, T finalDefaultValue) const {
+    T evaluate(float zoom, const Feature& feature, optional<PropertyMap> featureState, T finalDefaultValue) const {
         assert(!expression::isFeatureConstant(*expression));
-        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext({zoom}, &feature));
+        const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext({zoom}, &feature, featureState));
         if (result) {
             const optional<T> typed = expression::fromExpressionValue<T>(*result);
             return typed ? *typed : defaultValue ? *defaultValue : finalDefaultValue;
@@ -87,10 +88,10 @@ public:
 
     // Return the range obtained by evaluating the function at each of the zoom levels in zoomRange
     template <class Feature>
-    Range<T> evaluate(const Range<float>& zoomRange, const Feature& feature, T finalDefaultValue) {
+    Range<T> evaluate(const Range<float>& zoomRange, const Feature& feature, optional<PropertyMap> featureState, T finalDefaultValue) {
         return Range<T> {
-            evaluate(zoomRange.min, feature, finalDefaultValue),
-            evaluate(zoomRange.max, feature, finalDefaultValue)
+            evaluate(zoomRange.min, feature, featureState, finalDefaultValue),
+            evaluate(zoomRange.max, feature, featureState, finalDefaultValue)
         };
     }
 
diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp
index 651e3b9c5..61750dfa6 100644
--- a/src/mbgl/geometry/feature_index.cpp
+++ b/src/mbgl/geometry/feature_index.cpp
@@ -160,7 +160,7 @@ void FeatureIndex::addFeature(
             continue;
         }
 
-        if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(tileID.z), geometryTileFeature.get() })) {
+        if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(tileID.z), geometryTileFeature.get(), {}})) {
             continue;
         }
 
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index 0ffac36b7..50c4bc25b 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -62,7 +62,7 @@ public:
         const size_t featureCount = sourceLayer->featureCount();
         for (size_t i = 0; i < featureCount; ++i) {
             auto feature = sourceLayer->getFeature(i);
-            if (!leader.filter(style::expression::EvaluationContext { this->zoom, feature.get() }))
+            if (!leader.filter(style::expression::EvaluationContext { this->zoom, feature.get(), {} }))
                 continue;
 
             std::unordered_map<std::string, PatternDependency> patternDependencyMap;
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 74abd74f0..c67c30bca 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -100,7 +100,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
     const size_t featureCount = sourceLayer->featureCount();
     for (size_t i = 0; i < featureCount; ++i) {
         auto feature = sourceLayer->getFeature(i);
-        if (!leader.filter(expression::EvaluationContext { this->zoom, feature.get() }))
+        if (!leader.filter(expression::EvaluationContext { this->zoom, feature.get(), {} }))
             continue;
         
         SymbolFeature ft(std::move(feature));
diff --git a/src/mbgl/programs/symbol_program.hpp b/src/mbgl/programs/symbol_program.hpp
index 272c72ef9..73fd99068 100644
--- a/src/mbgl/programs/symbol_program.hpp
+++ b/src/mbgl/programs/symbol_program.hpp
@@ -195,7 +195,7 @@ public:
     }
 
     Range<float> getVertexSizeData(const GeometryTileFeature& feature) override {
-        const float size = expression.evaluate(feature, defaultValue);
+        const float size = expression.evaluate(feature, {}, defaultValue);
         return { size, size };
     };
 
@@ -220,8 +220,8 @@ public:
 
     Range<float> getVertexSizeData(const GeometryTileFeature& feature) override {
         return {
-            expression.evaluate(coveringZoomStops.min, feature, defaultValue),
-            expression.evaluate(coveringZoomStops.max, feature, defaultValue)
+            expression.evaluate(coveringZoomStops.min, feature, {}, defaultValue),
+            expression.evaluate(coveringZoomStops.max, feature, {}, defaultValue)
         };
     };
 
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index 31abec68a..46fc5302c 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -173,7 +173,7 @@ public:
     }
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) override {};
     void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, const ImagePositions&, const optional<PatternDependency>&) override {
-        auto evaluated = expression.evaluate(feature, defaultValue);
+        auto evaluated = expression.evaluate(feature, {}, defaultValue);
         this->statistics.add(evaluated);
         auto value = attributeValue(evaluated);
         for (std::size_t i = vertexVector.vertexSize(); i < length; ++i) {
@@ -228,7 +228,7 @@ public:
     }
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) override {};
     void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, const ImagePositions&, const optional<PatternDependency>&) override {
-        Range<T> range = expression.evaluate(zoomRange, feature, defaultValue);
+        Range<T> range = expression.evaluate(zoomRange, feature, {}, defaultValue);
         this->statistics.add(range.min);
         this->statistics.add(range.max);
         AttributeValue value = zoomInterpolatedAttributeValue(
diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
index 353df2ab9..539df0933 100644
--- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp
+++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
@@ -47,9 +47,9 @@ public:
             [&] (const T& constant_) { return constant_; },
             [&] (const style::PropertyExpression<T>& expression) {
                 if (useIntegerZoom) {
-                    return expression.evaluate(floor(zoom), feature, defaultValue);
+                    return expression.evaluate(floor(zoom), feature, {}, defaultValue);
                 } else {
-                    return expression.evaluate(zoom, feature, defaultValue);
+                    return expression.evaluate(zoom, feature, {}, defaultValue);
                 }
             }
         );
@@ -98,11 +98,11 @@ public:
             [&] (const Faded<T>& constant_) { return constant_; },
             [&] (const style::PropertyExpression<T>& expression) {
                 if (!expression.isZoomConstant()) {
-                    const T min = expression.evaluate(floor(zoom), feature, defaultValue);
-                    const T max = expression.evaluate(floor(zoom) + 1, feature, defaultValue);
+                    const T min = expression.evaluate(floor(zoom), feature, {}, defaultValue);
+                    const T max = expression.evaluate(floor(zoom) + 1, feature, {}, defaultValue);
                     return Faded<T> {min, max};
                 } else {
-                    const T evaluated = expression.evaluate(feature, defaultValue);
+                    const T evaluated = expression.evaluate(feature, {}, defaultValue);
                     return Faded<T> {evaluated, evaluated};
                 }
             }
diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp
index fc47b2d78..3e01ad593 100644
--- a/src/mbgl/style/expression/compound_expression.cpp
+++ b/src/mbgl/style/expression/compound_expression.cpp
@@ -409,6 +409,20 @@ std::unordered_map<std::string, CompoundExpressionRegistry::Definition> initiali
         }
     });
 
+    define("feature-state", [](const EvaluationContext& params, const std::string& key) -> Result<Value> {
+        if (!params.feature || !params.featureState) {
+            return EvaluationError {
+                "Feature state data is unavailable in the current evaluation context."
+            };
+        }
+
+        auto statePair = params.featureState->find(key);
+        if (statePair == params.featureState->end()) {
+            return Null;
+        }
+        return Value(toExpressionValue(statePair->second));
+    });
+
     define("id", [](const EvaluationContext& params) -> Result<Value> {
         if (!params.feature) {
             return EvaluationError {
diff --git a/src/mbgl/style/expression/expression.cpp b/src/mbgl/style/expression/expression.cpp
index 3c2580de0..54894b416 100644
--- a/src/mbgl/style/expression/expression.cpp
+++ b/src/mbgl/style/expression/expression.cpp
@@ -28,9 +28,9 @@ public:
 };
 
 
-EvaluationResult Expression::evaluate(optional<float> zoom, const Feature& feature, optional<double> colorRampParameter) const {
+EvaluationResult Expression::evaluate(optional<float> zoom, const Feature& feature, optional<PropertyMap> featureState, optional<double> colorRampParameter) const {
     GeoJSONFeature f(feature);
-    return this->evaluate(EvaluationContext(zoom, &f, colorRampParameter));
+    return this->evaluate(EvaluationContext(zoom, &f, featureState, colorRampParameter));
 }
 
 } // namespace expression
diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp
index 3b20f49a8..77c3b174d 100644
--- a/src/mbgl/style/expression/is_constant.cpp
+++ b/src/mbgl/style/expression/is_constant.cpp
@@ -23,7 +23,8 @@ bool isFeatureConstant(const Expression& expression) {
         } else if (
             name == "properties" ||
             name == "geometry-type" ||
-            name == "id"
+            name == "id" ||
+            name == "feature-state"
         ) {
             return false;
         }
@@ -48,6 +49,9 @@ bool isFeatureConstant(const Expression& expression) {
 bool isZoomConstant(const Expression& e) {
     return isGlobalPropertyConstant(e, std::array<std::string, 1>{{"zoom"}});
 }
+bool isFeatureStateConstant(const Expression& e) {
+    return isGlobalPropertyConstant(e, std::array<std::string, 1>{{"feature-state"}});
+}
 
 
 } // namespace expression
diff --git a/src/mbgl/style/expression/parsing_context.cpp b/src/mbgl/style/expression/parsing_context.cpp
index 0373b9721..e309d9a89 100644
--- a/src/mbgl/style/expression/parsing_context.cpp
+++ b/src/mbgl/style/expression/parsing_context.cpp
@@ -197,7 +197,7 @@ ParseResult ParsingContext::parse(const Convertible& value, optional<TypeAnnotat
     // it immediately and replace it with a literal value in the
     // parsed result.
     if ((*parsed)->getKind() != Kind::Literal && isConstant(**parsed)) {
-        EvaluationContext params(nullptr);
+        EvaluationContext params(nullptr, {});
         EvaluationResult evaluated((*parsed)->evaluate(params));
         if (!evaluated) {
             error(evaluated.error().message);
diff --git a/src/mbgl/style/properties.hpp b/src/mbgl/style/properties.hpp
index e7f05db95..1210ed914 100644
--- a/src/mbgl/style/properties.hpp
+++ b/src/mbgl/style/properties.hpp
@@ -155,7 +155,7 @@ public:
                     return t;
                 },
                 [&] (const PropertyExpression<T>& t) {
-                    return t.evaluate(z, feature, defaultValue);
+                    return t.evaluate(z, feature, {}, defaultValue);
                 });
         }
 
diff --git a/src/mbgl/tile/custom_geometry_tile.cpp b/src/mbgl/tile/custom_geometry_tile.cpp
index 24f352618..5b60fa140 100644
--- a/src/mbgl/tile/custom_geometry_tile.cpp
+++ b/src/mbgl/tile/custom_geometry_tile.cpp
@@ -78,7 +78,7 @@ void CustomGeometryTile::querySourceFeatures(
             auto feature = layer->getFeature(i);
             
             // Apply filter, if any
-            if (queryOptions.filter && !(*queryOptions.filter)(style::expression::EvaluationContext { static_cast<float>(id.overscaledZ), feature.get() })) {
+            if (queryOptions.filter && !(*queryOptions.filter)(style::expression::EvaluationContext { static_cast<float>(id.overscaledZ), feature.get(), {} })) {
                 continue;
             }
 
diff --git a/src/mbgl/tile/geojson_tile.cpp b/src/mbgl/tile/geojson_tile.cpp
index 7a83da226..c926a15ad 100644
--- a/src/mbgl/tile/geojson_tile.cpp
+++ b/src/mbgl/tile/geojson_tile.cpp
@@ -29,7 +29,7 @@ void GeoJSONTile::querySourceFeatures(
                 auto feature = layer->getFeature(i);
 
                 // Apply filter, if any
-                if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get() })) {
+                if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get(), {} })) {
                     continue;
                 }
 
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 9743cd3f7..5b81156bc 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -273,7 +273,7 @@ void GeometryTile::querySourceFeatures(
                 auto feature = layer->getFeature(i);
 
                 // Apply filter, if any
-                if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get() })) {
+                if (options.filter && !(*options.filter)(style::expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get(), {} })) {
                     continue;
                 }
 
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index c9032894a..9d3a1faf3 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -384,7 +384,7 @@ void GeometryTileWorker::parse() {
             for (std::size_t i = 0; !obsolete && i < geometryLayer->featureCount(); i++) {
                 std::unique_ptr<GeometryTileFeature> feature = geometryLayer->getFeature(i);
 
-                if (!filter(expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get() }))
+                if (!filter(expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get(), {} }))
                     continue;
 
                 GeometryCollection geometries = feature->getGeometries();
diff --git a/test/style/filter.test.cpp b/test/style/filter.test.cpp
index 9678fe089..37a5309b4 100644
--- a/test/style/filter.test.cpp
+++ b/test/style/filter.test.cpp
@@ -31,7 +31,7 @@ bool filter(const char * json,
     EXPECT_EQ(error.message, "");
     
     StubGeometryTileFeature feature { featureId, featureType, featureGeometry, featureProperties };
-    expression::EvaluationContext context = { zoom, &feature };
+    expression::EvaluationContext context = { zoom, &feature, {} };
     
     return (*filter)(context);
 }
diff --git a/test/style/property_expression.test.cpp b/test/style/property_expression.test.cpp
index e4ee5f115..4e972d71b 100644
--- a/test/style/property_expression.test.cpp
+++ b/test/style/property_expression.test.cpp
@@ -48,13 +48,13 @@ TEST(PropertyExpression, Expression) {
 
 TEST(PropertyExpression, Defaults) {
     EXPECT_EQ(1.0f, PropertyExpression<float>(number(get("property")), 0.0)
-        .evaluate(oneInteger, 2.0f));
+        .evaluate(oneInteger, {}, 2.0f));
     EXPECT_EQ(1.0f, PropertyExpression<float>(number(get("property")), 0.0)
-        .evaluate(oneDouble, 2.0f));
+        .evaluate(oneDouble, {}, 2.0f));
     EXPECT_EQ(0.0f, PropertyExpression<float>(number(get("property")), 0.0)
-        .evaluate(oneString, 2.0f));
+        .evaluate(oneString, {}, 2.0f));
     EXPECT_EQ(2.0f, PropertyExpression<float>(number(get("property")))
-        .evaluate(oneString, 2.0f));
+        .evaluate(oneString, {}, 2.0f));
 }
 
 TEST(PropertyExpression, ZoomInterpolation) {
@@ -64,35 +64,35 @@ TEST(PropertyExpression, ZoomInterpolation) {
             1.5, interpolate(linear(), number(get("property")), 1.0, literal(36.0)),
             3.0, interpolate(linear(), number(get("property")), 1.0, literal(48.0))
         ), 0.0f)
-    .evaluate(2.0f, oneInteger, -1.0f)) << "Should interpolate between stops";
+    .evaluate(2.0f, oneInteger, {}, -1.0f)) << "Should interpolate between stops";
     
     EXPECT_EQ(33.0, PropertyExpression<float>(
         interpolate(linear(), zoom(),
             5.0, interpolate(linear(), number(get("property")), 1.0, literal(33.0)),
             10.0, interpolate(linear(), number(get("property")), 1.0, literal(66.0))
         ), 0.0f)
-    .evaluate(0.0f, oneInteger, -1.0f)) << "Use first stop output for input values from -inf to first stop";
+    .evaluate(0.0f, oneInteger, {}, -1.0f)) << "Use first stop output for input values from -inf to first stop";
     
     EXPECT_EQ(66.0, PropertyExpression<float>(
         interpolate(linear(), zoom(),
             0.0, interpolate(linear(), number(get("property")), 1.0, literal(33.0)),
             10.0, interpolate(linear(), number(get("property")), 1.0, literal(66.0))
         ), 0.0f)
-    .evaluate(20.0f, oneInteger, -1.0f)) << "Use last stop output for input values from last stop to +inf";
+    .evaluate(20.0f, oneInteger, {}, -1.0f)) << "Use last stop output for input values from last stop to +inf";
 
     EXPECT_EQ(66.0f, PropertyExpression<float>(
         interpolate(linear(), zoom(),
             0.0, interpolate(linear(), number(get("property")), 1.0, literal(33.0)),
             10.0, interpolate(linear(), number(get("property")), 1.0, literal(66.0))
         ), 0.0f)
-    .evaluate(10.0f, oneInteger, -1.0f)) << "Should interpolate TO the last stop.";
+    .evaluate(10.0f, oneInteger, {}, -1.0f)) << "Should interpolate TO the last stop.";
     
     EXPECT_EQ(33.0f, PropertyExpression<float>(
         interpolate(linear(), zoom(),
             0.0, interpolate(linear(), number(get("property")), 1.0, literal(33.0)),
             10.0, interpolate(linear(), number(get("property")), 1.0, literal(66.0))
         ), 0.0f)
-    .evaluate(0.0f, oneInteger, -1.0f)) << "Should interpolate TO the first stop";
+    .evaluate(0.0f, oneInteger, {}, -1.0f)) << "Should interpolate TO the first stop";
 }
 
 TEST(PropertyExpression, Issue8460) {
@@ -102,10 +102,10 @@ TEST(PropertyExpression, Issue8460) {
             15.2, interpolate(linear(), number(get("property")), 1.0, literal(600.0))
         ), 0.0f);
 
-    EXPECT_NEAR(  0.0f, fn1.evaluate(15.0f, oneInteger, -1.0f), 0.00);
-    EXPECT_NEAR(300.0f, fn1.evaluate(15.1f, oneInteger, -1.0f), 0.01);
-    EXPECT_NEAR(600.0f, fn1.evaluate(15.2f, oneInteger, -1.0f), 0.00);
-    EXPECT_NEAR(600.0f, fn1.evaluate(16.0f, oneInteger, -1.0f), 0.00);
+    EXPECT_NEAR(  0.0f, fn1.evaluate(15.0f, oneInteger, {}, -1.0f), 0.00);
+    EXPECT_NEAR(300.0f, fn1.evaluate(15.1f, oneInteger, {}, -1.0f), 0.01);
+    EXPECT_NEAR(600.0f, fn1.evaluate(15.2f, oneInteger, {}, -1.0f), 0.00);
+    EXPECT_NEAR(600.0f, fn1.evaluate(16.0f, oneInteger, {}, -1.0f), 0.00);
 
     PropertyExpression<float> fn2(
         interpolate(linear(), zoom(),
@@ -114,10 +114,10 @@ TEST(PropertyExpression, Issue8460) {
             18.0, interpolate(linear(), number(get("property")), 1.0, literal(600.0))
         ), 0.0f);
 
-    EXPECT_NEAR(  0.0f, fn2.evaluate(15.0f, oneInteger, -1.0f), 0.00);
-    EXPECT_NEAR(150.0f, fn2.evaluate(15.1f, oneInteger, -1.0f), 0.01);
-    EXPECT_NEAR(300.0f, fn2.evaluate(15.2f, oneInteger, -1.0f), 0.00);
-    EXPECT_NEAR(385.71f, fn2.evaluate(16.0f, oneInteger, -1.0f), 0.01);
-    EXPECT_NEAR(600.0f, fn2.evaluate(18.0f, oneInteger, -1.0f), 0.00);
-    EXPECT_NEAR(600.0f, fn2.evaluate(19.0f, oneInteger, -1.0f), 0.00);
+    EXPECT_NEAR(  0.0f, fn2.evaluate(15.0f, oneInteger, {}, -1.0f), 0.00);
+    EXPECT_NEAR(150.0f, fn2.evaluate(15.1f, oneInteger, {}, -1.0f), 0.01);
+    EXPECT_NEAR(300.0f, fn2.evaluate(15.2f, oneInteger, {}, -1.0f), 0.00);
+    EXPECT_NEAR(385.71f, fn2.evaluate(16.0f, oneInteger, {}, -1.0f), 0.01);
+    EXPECT_NEAR(600.0f, fn2.evaluate(18.0f, oneInteger, {}, -1.0f), 0.00);
+    EXPECT_NEAR(600.0f, fn2.evaluate(19.0f, oneInteger, {}, -1.0f), 0.00);
 }