Refactor is*Constant()

 - Prepares for 'constant folding'
 - Also replaces 'accept(visitor)' with simpler 'eachChild()' (as we did
 in JS)

33 files changed, 141 insertions, 111 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index 18ac5831dc..206a1c8d25 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -405,6 +405,7 @@ set(MBGL_CORE_FILES
     include/mbgl/style/expression/compound_expression.hpp
     include/mbgl/style/expression/curve.hpp
     include/mbgl/style/expression/expression.hpp
+    include/mbgl/style/expression/is_constant.hpp
     include/mbgl/style/expression/let.hpp
     include/mbgl/style/expression/literal.hpp
     include/mbgl/style/expression/match.hpp
@@ -421,6 +422,7 @@ set(MBGL_CORE_FILES
     src/mbgl/style/expression/coercion.cpp
     src/mbgl/style/expression/compound_expression.cpp
     src/mbgl/style/expression/curve.cpp
+    src/mbgl/style/expression/is_constant.cpp
     src/mbgl/style/expression/let.cpp
     src/mbgl/style/expression/literal.cpp
     src/mbgl/style/expression/match.cpp
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index 186dced0af..aac09aa343 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/conversion/function.hpp>
 #include <mbgl/style/conversion/expression.hpp>
 #include <mbgl/style/expression/curve.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 
 namespace mbgl {
 namespace style {
@@ -31,9 +32,9 @@ struct Converter<DataDrivenPropertyValue<T>> {
             if (!expression) {
                 return {};
             }
-            if ((*expression)->isFeatureConstant()) {
+            if (isFeatureConstant(expression->get())) {
                 return DataDrivenPropertyValue<T>(CameraFunction<T>(std::move(*expression)));
-            } else if ((*expression)->isZoomConstant()) {
+            } else if (isZoomConstant(expression->get())) {
                 return DataDrivenPropertyValue<T>(SourceFunction<T>(std::move(*expression)));
             } else {
                 if (!CompositeFunction<T>::Curve::findZoomCurve(expression->get())) {
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 6cf85019bc..fd9b47b090 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/conversion/function.hpp>
 #include <mbgl/style/conversion/expression.hpp>
 #include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 
 namespace mbgl {
 namespace style {
@@ -21,7 +22,7 @@ struct Converter<PropertyValue<T>> {
             if (!expression) {
                 return {};
             }
-            if ((*expression)->isFeatureConstant()) {
+            if (isFeatureConstant(expression->get())) {
                 return { CameraFunction<T>(std::move(*expression)) };
             } else {
                 error = { "data-driven style property not supported " };
diff --git a/include/mbgl/style/expression/array_assertion.hpp b/include/mbgl/style/expression/array_assertion.hpp
index 038300341e..4fbd9530ce 100644
--- a/include/mbgl/style/expression/array_assertion.hpp
+++ b/include/mbgl/style/expression/array_assertion.hpp
@@ -24,7 +24,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     std::unique_ptr<Expression> input;
diff --git a/include/mbgl/style/expression/assertion.hpp b/include/mbgl/style/expression/assertion.hpp
index 7df0d1f440..01c55ae92c 100644
--- a/include/mbgl/style/expression/assertion.hpp
+++ b/include/mbgl/style/expression/assertion.hpp
@@ -15,7 +15,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
diff --git a/include/mbgl/style/expression/at.hpp b/include/mbgl/style/expression/at.hpp
index 6d2c3ea88a..f29c605973 100644
--- a/include/mbgl/style/expression/at.hpp
+++ b/include/mbgl/style/expression/at.hpp
@@ -18,7 +18,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
     
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)>) const override;
+    void eachChild(std::function<void(const Expression*)>) const override;
 
 private:
     std::unique_ptr<Expression> index;
diff --git a/include/mbgl/style/expression/boolean_operator.hpp b/include/mbgl/style/expression/boolean_operator.hpp
index db86e63a39..284b5cb04f 100644
--- a/include/mbgl/style/expression/boolean_operator.hpp
+++ b/include/mbgl/style/expression/boolean_operator.hpp
@@ -15,7 +15,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
@@ -31,7 +31,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
diff --git a/include/mbgl/style/expression/case.hpp b/include/mbgl/style/expression/case.hpp
index bb68058141..e54f8651e8 100644
--- a/include/mbgl/style/expression/case.hpp
+++ b/include/mbgl/style/expression/case.hpp
@@ -20,7 +20,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     std::vector<Branch> branches;
diff --git a/include/mbgl/style/expression/coalesce.hpp b/include/mbgl/style/expression/coalesce.hpp
index eaf9d0c0d1..e3b5ef8e75 100644
--- a/include/mbgl/style/expression/coalesce.hpp
+++ b/include/mbgl/style/expression/coalesce.hpp
@@ -23,7 +23,7 @@ public:
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
     
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
     std::size_t getLength() const {
         return args.size();
diff --git a/include/mbgl/style/expression/coercion.hpp b/include/mbgl/style/expression/coercion.hpp
index 30c5167258..882cf2a0c3 100644
--- a/include/mbgl/style/expression/coercion.hpp
+++ b/include/mbgl/style/expression/coercion.hpp
@@ -17,7 +17,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
 private:
     EvaluationResult (*coerceSingleValue) (const Value& v);
diff --git a/include/mbgl/style/expression/compound_expression.hpp b/include/mbgl/style/expression/compound_expression.hpp
index 07b6fecb82..8852f8f955 100644
--- a/include/mbgl/style/expression/compound_expression.hpp
+++ b/include/mbgl/style/expression/compound_expression.hpp
@@ -96,10 +96,9 @@ public:
         return signature.apply(evaluationParams, args);
     }
     
-    void accept(std::function<void(const Expression*)> visitor) const override {
-        visitor(this);
+    void eachChild(std::function<void(const Expression*)> visit) const override {
         for (const std::unique_ptr<Expression>& e : args) {
-            e->accept(visitor);
+            visit(e.get());
         }
     }
     
diff --git a/include/mbgl/style/expression/curve.hpp b/include/mbgl/style/expression/curve.hpp
index 494d256415..d77dd503e6 100644
--- a/include/mbgl/style/expression/curve.hpp
+++ b/include/mbgl/style/expression/curve.hpp
@@ -111,12 +111,10 @@ public:
         
     }
     
-    void accept(std::function<void(const Expression*)> visit) const override {
-        visit(this);
-        input->accept(visit);
-        
+    void eachChild(std::function<void(const Expression*)> visit) const override {
+        visit(input.get());
         for (auto it = stops.begin(); it != stops.end(); it++) {
-            it->second->accept(visit);
+            visit(it->second.get());
         }
     }
     
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index 6c0f11a675..8da38eaffc 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -112,11 +112,8 @@ public:
     virtual ~Expression() = default;
     
     virtual EvaluationResult evaluate(const EvaluationParameters& params) const = 0;
-    
-    virtual void accept(std::function<void(const Expression*)>) const = 0;
+    virtual void eachChild(std::function<void(const Expression*)>) const = 0;
 
-    bool isFeatureConstant() const;
-    bool isZoomConstant() const;
     type::Type getType() const { return type; };
     
     EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<double> heatmapDensity) const;
diff --git a/include/mbgl/style/expression/is_constant.hpp b/include/mbgl/style/expression/is_constant.hpp
new file mode 100644
index 0000000000..5e20240be7
--- /dev/null
+++ b/include/mbgl/style/expression/is_constant.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <mbgl/style/expression/expression.hpp>
+#include <mbgl/style/expression/compound_expression.hpp>
+
+namespace mbgl {
+namespace style {
+namespace expression {
+
+template <typename T>
+bool isGlobalPropertyConstant(const Expression* expression, const T& properties) {
+    if (auto e = dynamic_cast<const CompoundExpressionBase*>(expression)) {
+        for (const std::string& property : properties) {
+            if (e->getName() == property) {
+                return false;
+            }
+        }
+    }
+    
+    bool isConstant = true;
+    expression->eachChild([&](const Expression* e) {
+        if (isConstant && !isGlobalPropertyConstant(e, properties)) {
+            isConstant = false;
+        }
+    });
+    return isConstant;
+};
+
+bool isFeatureConstant(const Expression* expression);
+bool isZoomConstant(const Expression* e);
+
+
+} // namespace expression
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/expression/let.hpp b/include/mbgl/style/expression/let.hpp
index 5e6e3a1696..a403e20d40 100644
--- a/include/mbgl/style/expression/let.hpp
+++ b/include/mbgl/style/expression/let.hpp
@@ -21,7 +21,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext);
     
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)>) const override;
+    void eachChild(std::function<void(const Expression*)>) const override;
     
     Expression* getResult() const {
         return result.get();
@@ -43,7 +43,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext);
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
-    void accept(std::function<void(const Expression*)>) const override;
+    void eachChild(std::function<void(const Expression*)>) const override;
 
 private:
     std::string name;
diff --git a/include/mbgl/style/expression/literal.hpp b/include/mbgl/style/expression/literal.hpp
index 18c2b56e92..e4c12e17d4 100644
--- a/include/mbgl/style/expression/literal.hpp
+++ b/include/mbgl/style/expression/literal.hpp
@@ -26,9 +26,7 @@ public:
     
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext);
 
-    void accept(std::function<void(const Expression*)> visit) const override {
-        visit(this);
-    }
+    void eachChild(std::function<void(const Expression*)>) const override {}
     
 private:
     Value value;
diff --git a/include/mbgl/style/expression/match.hpp b/include/mbgl/style/expression/match.hpp
index 3038097868..4a0d35f96e 100644
--- a/include/mbgl/style/expression/match.hpp
+++ b/include/mbgl/style/expression/match.hpp
@@ -26,7 +26,7 @@ public:
         otherwise(std::move(otherwise_))
     {}
 
-    void accept(std::function<void(const Expression*)> visit) const override;
+    void eachChild(std::function<void(const Expression*)> visit) const override;
 
     EvaluationResult evaluate(const EvaluationParameters& params) const override;
     
diff --git a/include/mbgl/style/function/camera_function.hpp b/include/mbgl/style/function/camera_function.hpp
index 0dc962fb3a..cf43940a13 100644
--- a/include/mbgl/style/function/camera_function.hpp
+++ b/include/mbgl/style/function/camera_function.hpp
@@ -3,12 +3,14 @@
 #include <mbgl/style/expression/expression.hpp>
 #include <mbgl/style/expression/curve.hpp>
 #include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/function/convert.hpp>
 #include <mbgl/style/function/exponential_stops.hpp>
 #include <mbgl/style/function/interval_stops.hpp>
 #include <mbgl/util/interpolate.hpp>
 #include <mbgl/util/variant.hpp>
 
+
 namespace mbgl {
 namespace style {
 
@@ -29,8 +31,8 @@ public:
         : expression(std::move(expression_)),
           zoomCurve(*Curve::findZoomCurve(expression.get()))
     {
-        assert(!expression->isZoomConstant());
-        assert(expression->isFeatureConstant());
+        assert(!isZoomConstant(expression.get()));
+        assert(isFeatureConstant(expression.get()));
     }
 
     CameraFunction(Stops stops_)
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp
index 57c1fe18cb..9aa72ec65d 100644
--- a/include/mbgl/style/function/composite_function.hpp
+++ b/include/mbgl/style/function/composite_function.hpp
@@ -3,6 +3,7 @@
 #include <mbgl/style/expression/expression.hpp>
 #include <mbgl/style/expression/curve.hpp>
 #include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/function/convert.hpp>
 #include <mbgl/style/function/composite_exponential_stops.hpp>
 #include <mbgl/style/function/composite_interval_stops.hpp>
@@ -53,8 +54,8 @@ public:
     :   expression(std::move(expression_)),
         zoomCurve(*Curve::findZoomCurve(expression.get()))
     {
-        assert(!expression->isZoomConstant());
-        assert(!expression->isFeatureConstant());
+        assert(!isZoomConstant(expression.get()));
+        assert(!isFeatureConstant(expression.get()));
     }
 
     CompositeFunction(std::string property_, Stops stops_, optional<T> defaultValue_ = {})
diff --git a/include/mbgl/style/function/convert.hpp b/include/mbgl/style/function/convert.hpp
index 1082b06971..0e85299c09 100644
--- a/include/mbgl/style/function/convert.hpp
+++ b/include/mbgl/style/function/convert.hpp
@@ -31,9 +31,7 @@ namespace detail {
 class ErrorExpression : public Expression {
 public:
     ErrorExpression(std::string message_) : Expression(type::Error), message(std::move(message_)) {}
-    void accept(std::function<void(const Expression*)> visit) const override {
-        visit(this);
-    }
+    void eachChild(std::function<void(const Expression*)>) const override {}
 
     EvaluationResult evaluate(const EvaluationParameters&) const override {
         return EvaluationError{message};
diff --git a/include/mbgl/style/function/source_function.hpp b/include/mbgl/style/function/source_function.hpp
index 5525429821..007be4d1e3 100644
--- a/include/mbgl/style/function/source_function.hpp
+++ b/include/mbgl/style/function/source_function.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
+#include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/function/convert.hpp>
-
 #include <mbgl/style/function/exponential_stops.hpp>
 #include <mbgl/style/function/interval_stops.hpp>
 #include <mbgl/style/function/categorical_stops.hpp>
@@ -32,8 +32,8 @@ public:
     SourceFunction(std::unique_ptr<expression::Expression> expression_)
         : expression(std::move(expression_))
     {
-        assert(expression->isZoomConstant());
-        assert(!expression->isFeatureConstant());
+        assert(isZoomConstant(expression.get()));
+        assert(!isFeatureConstant(expression.get()));
     }
     
     SourceFunction(std::string property_, Stops stops_, optional<T> defaultValue_ = {})
diff --git a/platform/node/src/node_expression.cpp b/platform/node/src/node_expression.cpp
index 38a444f203..8ab3e71f9e 100644
--- a/platform/node/src/node_expression.cpp
+++ b/platform/node/src/node_expression.cpp
@@ -2,6 +2,7 @@
 #include "node_expression.hpp"
 
 #include <mbgl/style/expression/parsing_context.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/conversion/geojson.hpp>
 #include <mbgl/util/geojson.hpp>
 #include <nan.h>
@@ -217,13 +218,13 @@ void NodeExpression::GetType(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 void NodeExpression::IsFeatureConstant(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
     const std::unique_ptr<Expression>& expression = nodeExpr->expression;
-    info.GetReturnValue().Set(Nan::New(expression->isFeatureConstant()));
+    info.GetReturnValue().Set(Nan::New(isFeatureConstant(expression.get())));
 }
 
 void NodeExpression::IsZoomConstant(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
     const std::unique_ptr<Expression>& expression = nodeExpr->expression;
-    info.GetReturnValue().Set(Nan::New(expression->isZoomConstant()));
+    info.GetReturnValue().Set(Nan::New(isZoomConstant(expression.get())));
 }
 
 } // namespace node_mbgl
diff --git a/src/mbgl/style/expression/array_assertion.cpp b/src/mbgl/style/expression/array_assertion.cpp
index 6acd76897c..73b3674d32 100644
--- a/src/mbgl/style/expression/array_assertion.cpp
+++ b/src/mbgl/style/expression/array_assertion.cpp
@@ -20,9 +20,8 @@ EvaluationResult ArrayAssertion::evaluate(const EvaluationParameters& params) co
     return *result;
 }
 
-void ArrayAssertion::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
-    input->accept(visit);
+void ArrayAssertion::eachChild(std::function<void(const Expression*)> visit) const {
+    visit(input.get());
 }
 
 ParseResult ArrayAssertion::parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx) {
diff --git a/src/mbgl/style/expression/assertion.cpp b/src/mbgl/style/expression/assertion.cpp
index acef342e6f..0ff59a268c 100644
--- a/src/mbgl/style/expression/assertion.cpp
+++ b/src/mbgl/style/expression/assertion.cpp
@@ -52,10 +52,9 @@ EvaluationResult Assertion::evaluate(const EvaluationParameters& params) const {
     return EvaluationResult();
 };
 
-void Assertion::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Assertion::eachChild(std::function<void(const Expression*)> visit) const {
     for(const std::unique_ptr<Expression>& input : inputs) {
-        input->accept(visit);
+        visit(input.get());
     }
 };
 
diff --git a/src/mbgl/style/expression/at.cpp b/src/mbgl/style/expression/at.cpp
index 042a902979..43d8d82bef 100644
--- a/src/mbgl/style/expression/at.cpp
+++ b/src/mbgl/style/expression/at.cpp
@@ -32,10 +32,9 @@ EvaluationResult At::evaluate(const EvaluationParameters& params) const {
     return inputArray[static_cast<std::size_t>(i)];
 }
 
-void At::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
-    index->accept(visit);
-    input->accept(visit);
+void At::eachChild(std::function<void(const Expression*)> visit) const {
+    visit(index.get());
+    visit(input.get());
 }
 
 ParseResult At::parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx) {
diff --git a/src/mbgl/style/expression/boolean_operator.cpp b/src/mbgl/style/expression/boolean_operator.cpp
index 48052af8e3..b0fcc8fd9a 100644
--- a/src/mbgl/style/expression/boolean_operator.cpp
+++ b/src/mbgl/style/expression/boolean_operator.cpp
@@ -13,10 +13,9 @@ EvaluationResult Any::evaluate(const EvaluationParameters& params) const {
     return EvaluationResult(false);
 }
 
-void Any::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Any::eachChild(std::function<void(const Expression*)> visit) const {
     for (const std::unique_ptr<Expression>& input : inputs) {
-        input->accept(visit);
+        visit(input.get());
     }
 }
 
@@ -29,10 +28,9 @@ EvaluationResult All::evaluate(const EvaluationParameters& params) const {
     return EvaluationResult(true);
 }
 
-void All::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void All::eachChild(std::function<void(const Expression*)> visit) const {
     for (const std::unique_ptr<Expression>& input : inputs) {
-        input->accept(visit);
+        visit(input.get());
     }
 }
 
diff --git a/src/mbgl/style/expression/case.cpp b/src/mbgl/style/expression/case.cpp
index 499f345454..68a940d06d 100644
--- a/src/mbgl/style/expression/case.cpp
+++ b/src/mbgl/style/expression/case.cpp
@@ -18,13 +18,12 @@ EvaluationResult Case::evaluate(const EvaluationParameters& params) const {
     return otherwise->evaluate(params);
 }
 
-void Case::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Case::eachChild(std::function<void(const Expression*)> visit) const {
     for (const Branch& branch : branches) {
-        branch.first->accept(visit);
-        branch.second->accept(visit);
+        visit(branch.first.get());
+        visit(branch.second.get());
     }
-    otherwise->accept(visit);
+    visit(otherwise.get());
 }
 
 ParseResult Case::parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx) {
diff --git a/src/mbgl/style/expression/coalesce.cpp b/src/mbgl/style/expression/coalesce.cpp
index ab0181812d..22e15066bd 100644
--- a/src/mbgl/style/expression/coalesce.cpp
+++ b/src/mbgl/style/expression/coalesce.cpp
@@ -13,10 +13,9 @@ EvaluationResult Coalesce::evaluate(const EvaluationParameters& params) const {
     return Null;
 }
 
-void Coalesce::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Coalesce::eachChild(std::function<void(const Expression*)> visit) const {
     for (const std::unique_ptr<Expression>& arg : args) {
-        arg->accept(visit);
+        visit(arg.get());
     }
 }
 
diff --git a/src/mbgl/style/expression/coercion.cpp b/src/mbgl/style/expression/coercion.cpp
index 3a0ef7fc1f..911dc8b989 100644
--- a/src/mbgl/style/expression/coercion.cpp
+++ b/src/mbgl/style/expression/coercion.cpp
@@ -121,10 +121,9 @@ EvaluationResult Coercion::evaluate(const EvaluationParameters& params) const {
     return EvaluationResult();
 };
 
-void Coercion::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Coercion::eachChild(std::function<void(const Expression*)> visit) const {
     for(const std::unique_ptr<Expression>& input : inputs) {
-        input->accept(visit);
+        visit(input.get());
     }
 };
 
diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp
new file mode 100644
index 0000000000..0794c90a3c
--- /dev/null
+++ b/src/mbgl/style/expression/is_constant.cpp
@@ -0,0 +1,40 @@
+#include <mbgl/style/expression/is_constant.hpp>
+
+namespace mbgl {
+namespace style {
+namespace expression {
+
+bool isFeatureConstant(const Expression* expression) {
+    if (auto e = dynamic_cast<const CompoundExpressionBase*>(expression)) {
+        const std::string name = e->getName();
+        optional<std::size_t> parameterCount = e->getParameterCount();
+        if (name == "get" && parameterCount && *parameterCount == 1) {
+            return false;
+        } else if (name == "has" && parameterCount && *parameterCount == 1) {
+            return false;
+        } else if (
+            name == "properties" ||
+            name == "geometry-type" ||
+            name == "id"
+        ) {
+            return false;
+        }
+    }
+
+    bool featureConstant = true;
+    expression->eachChild([&](const Expression* e) {
+        if (featureConstant && !isFeatureConstant(e)) {
+            featureConstant = false;
+        }
+    });
+    return featureConstant;
+}
+
+bool isZoomConstant(const Expression* e) {
+    return isGlobalPropertyConstant(e, std::array<std::string, 1>{{"zoom"}});
+}
+
+
+} // namespace expression
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/expression/let.cpp b/src/mbgl/style/expression/let.cpp
index 4dbffc4560..27b99c9640 100644
--- a/src/mbgl/style/expression/let.cpp
+++ b/src/mbgl/style/expression/let.cpp
@@ -9,12 +9,11 @@ EvaluationResult Let::evaluate(const EvaluationParameters& params) const {
     return result->evaluate(params);
 }
 
-void Let::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
+void Let::eachChild(std::function<void(const Expression*)> visit) const {
     for (auto it = bindings.begin(); it != bindings.end(); it++) {
-        it->second->accept(visit);
+        visit(it->second.get());
     }
-    result->accept(visit);
+    visit(result.get());
 }
 
 ParseResult Let::parse(const mbgl::style::conversion::Convertible& value, ParsingContext ctx) {
@@ -65,9 +64,7 @@ EvaluationResult Var::evaluate(const EvaluationParameters& params) const {
     return value->evaluate(params);
 }
 
-void Var::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
-}
+void Var::eachChild(std::function<void(const Expression*)>) const {}
 
 ParseResult Var::parse(const mbgl::style::conversion::Convertible& value_, ParsingContext ctx) {
     using namespace mbgl::style::conversion;
diff --git a/src/mbgl/style/expression/match.cpp b/src/mbgl/style/expression/match.cpp
index ad3dae684a..dd3349e9f9 100644
--- a/src/mbgl/style/expression/match.cpp
+++ b/src/mbgl/style/expression/match.cpp
@@ -6,13 +6,12 @@ namespace style {
 namespace expression {
 
 template <typename T>
-void Match<T>::accept(std::function<void(const Expression*)> visit) const {
-    visit(this);
-    input->accept(visit);
+void Match<T>::eachChild(std::function<void(const Expression*)> visit) const {
+    visit(input.get());
     for (const std::pair<T, std::shared_ptr<Expression>>& branch : branches) {
-        branch.second->accept(visit);
+        visit(branch.second.get());
     }
-    otherwise->accept(visit);
+    visit(otherwise.get());
 }
 
 template<> EvaluationResult Match<std::string>::evaluate(const EvaluationParameters& params) const {
diff --git a/src/mbgl/style/function/expression.cpp b/src/mbgl/style/function/expression.cpp
index e9cc0b0e1c..8f2c4a337c 100644
--- a/src/mbgl/style/function/expression.cpp
+++ b/src/mbgl/style/function/expression.cpp
@@ -27,37 +27,6 @@ public:
     }
 };
 
-bool Expression::isFeatureConstant() const {
-    bool featureConstant = true;
-    accept([&](const Expression* expression) {
-        if (auto e = dynamic_cast<const CompoundExpressionBase*>(expression)) {
-            const std::string name = e->getName();
-            if (name == "get" || name == "has") {
-                optional<std::size_t> parameterCount = e->getParameterCount();
-                featureConstant = featureConstant && (parameterCount && *parameterCount > 1);
-            } else {
-                featureConstant = featureConstant && !(
-                    name == "properties" ||
-                    name == "geometry-type" ||
-                    name == "id"
-                );
-            }
-        }
-    });
-    return featureConstant;
-}
-
-bool Expression::isZoomConstant() const {
-    bool zoomConstant = true;
-    accept([&](const Expression* expression) {
-        if (auto e = dynamic_cast<const CompoundExpressionBase*>(expression)) {
-            if (e->getName() == "zoom") {
-                zoomConstant = false;
-            }
-        }
-    });
-    return zoomConstant;
-}
 
 EvaluationResult Expression::evaluate(optional<float> zoom, const Feature& feature, optional<double> heatmapDensity) const {
     GeoJSONFeature f(feature);