Take reference rather than pointer in eachChild callback

34 files changed, 77 insertions, 77 deletions

diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index 7a0ac56ff4..37acb3f775 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -32,14 +32,14 @@ struct Converter<DataDrivenPropertyValue<T>> {
                 return {};
             }
             
-            bool zoomConstant = isZoomConstant(expression->get());
+            bool zoomConstant = isZoomConstant(**expression);
             
             if (!zoomConstant && !findZoomCurve<typename CameraFunction<T>::ExpressionType>(expression->get())) {
                 error = { R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)" };
                 return {};
             }
             
-            if (isFeatureConstant(expression->get())) {
+            if (isFeatureConstant(**expression)) {
                 return DataDrivenPropertyValue<T>(CameraFunction<T>(std::move(*expression)));
             } else if (zoomConstant) {
                 return DataDrivenPropertyValue<T>(SourceFunction<T>(std::move(*expression)));
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index d6c550ea03..50382b74d3 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -24,8 +24,8 @@ struct Converter<PropertyValue<T>> {
             if (!expression) {
                 return {};
             }
-            if (isFeatureConstant(expression->get())) {
-                if (!isZoomConstant(expression->get()) && !findZoomCurve<typename CameraFunction<T>::ExpressionType>(expression->get())) {
+            if (isFeatureConstant(**expression)) {
+                if (!isZoomConstant(**expression) && !findZoomCurve<typename CameraFunction<T>::ExpressionType>(expression->get())) {
                     error = { R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)" };
                     return {};
                 }
diff --git a/include/mbgl/style/expression/array_assertion.hpp b/include/mbgl/style/expression/array_assertion.hpp
index a86426737d..2516eea024 100644
--- a/include/mbgl/style/expression/array_assertion.hpp
+++ b/include/mbgl/style/expression/array_assertion.hpp
@@ -21,7 +21,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override {
         if (auto rhs = dynamic_cast<const ArrayAssertion*>(&e)) {
diff --git a/include/mbgl/style/expression/assertion.hpp b/include/mbgl/style/expression/assertion.hpp
index 7d26e87f5f..504d49f4e5 100644
--- a/include/mbgl/style/expression/assertion.hpp
+++ b/include/mbgl/style/expression/assertion.hpp
@@ -19,7 +19,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
     
     bool operator==(const Expression& e) const override;
 
diff --git a/include/mbgl/style/expression/at.hpp b/include/mbgl/style/expression/at.hpp
index a19b29d9af..e3eefa4fe8 100644
--- a/include/mbgl/style/expression/at.hpp
+++ b/include/mbgl/style/expression/at.hpp
@@ -19,7 +19,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
     
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>&) const override;
+    void eachChild(const std::function<void(const Expression&)>&) const override;
 
     bool operator==(const Expression& e) const override {
         if (auto rhs = dynamic_cast<const At*>(&e)) {
diff --git a/include/mbgl/style/expression/boolean_operator.hpp b/include/mbgl/style/expression/boolean_operator.hpp
index b9abe10664..01231d706b 100644
--- a/include/mbgl/style/expression/boolean_operator.hpp
+++ b/include/mbgl/style/expression/boolean_operator.hpp
@@ -18,7 +18,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
     bool operator==(const Expression& e) const override;
 
 private:
@@ -35,7 +35,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
 
diff --git a/include/mbgl/style/expression/case.hpp b/include/mbgl/style/expression/case.hpp
index fecee891f9..ece2fe0329 100644
--- a/include/mbgl/style/expression/case.hpp
+++ b/include/mbgl/style/expression/case.hpp
@@ -22,7 +22,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
     
     bool operator==(const Expression& e) const override;
 
diff --git a/include/mbgl/style/expression/coalesce.hpp b/include/mbgl/style/expression/coalesce.hpp
index ef169faa19..4e6a9b3793 100644
--- a/include/mbgl/style/expression/coalesce.hpp
+++ b/include/mbgl/style/expression/coalesce.hpp
@@ -24,7 +24,7 @@ public:
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
     
diff --git a/include/mbgl/style/expression/coercion.hpp b/include/mbgl/style/expression/coercion.hpp
index 5b0889475e..665bb7ce7c 100644
--- a/include/mbgl/style/expression/coercion.hpp
+++ b/include/mbgl/style/expression/coercion.hpp
@@ -20,7 +20,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
 private:
diff --git a/include/mbgl/style/expression/compound_expression.hpp b/include/mbgl/style/expression/compound_expression.hpp
index b19e7fe4d4..fc3edbfd4a 100644
--- a/include/mbgl/style/expression/compound_expression.hpp
+++ b/include/mbgl/style/expression/compound_expression.hpp
@@ -95,9 +95,9 @@ public:
         return signature.apply(evaluationParams, args);
     }
     
-    void eachChild(const std::function<void(const Expression*)>& visit) const override {
+    void eachChild(const std::function<void(const Expression&)>& visit) const override {
         for (const std::unique_ptr<Expression>& e : args) {
-            visit(e.get());
+            visit(*e);
         }
     }
 
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index 5999352ce2..1954d8b090 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -114,7 +114,7 @@ public:
     virtual ~Expression() = default;
     
     virtual EvaluationResult evaluate(const EvaluationContext& params) const = 0;
-    virtual void eachChild(const std::function<void(const Expression*)>&) const = 0;
+    virtual void eachChild(const std::function<void(const Expression&)>&) const = 0;
     virtual bool operator==(const Expression&) const = 0;
     bool operator!=(const Expression& rhs) const {
         return !operator==(rhs);
diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp
index b0b93ce911..b848265c1b 100644
--- a/include/mbgl/style/expression/interpolate.hpp
+++ b/include/mbgl/style/expression/interpolate.hpp
@@ -112,10 +112,10 @@ public:
         
     }
     
-    void eachChild(const std::function<void(const Expression*)>& visit) const override {
-        visit(input.get());
+    void eachChild(const std::function<void(const Expression&)>& visit) const override {
+        visit(*input);
         for (auto it = stops.begin(); it != stops.end(); it++) {
-            visit(it->second.get());
+            visit(*(it->second));
         }
     }
     
diff --git a/include/mbgl/style/expression/is_constant.hpp b/include/mbgl/style/expression/is_constant.hpp
index 5e20240be7..29e03ccbc0 100644
--- a/include/mbgl/style/expression/is_constant.hpp
+++ b/include/mbgl/style/expression/is_constant.hpp
@@ -8,8 +8,8 @@ namespace style {
 namespace expression {
 
 template <typename T>
-bool isGlobalPropertyConstant(const Expression* expression, const T& properties) {
-    if (auto e = dynamic_cast<const CompoundExpressionBase*>(expression)) {
+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;
@@ -18,7 +18,7 @@ bool isGlobalPropertyConstant(const Expression* expression, const T& properties)
     }
     
     bool isConstant = true;
-    expression->eachChild([&](const Expression* e) {
+    expression.eachChild([&](const Expression& e) {
         if (isConstant && !isGlobalPropertyConstant(e, properties)) {
             isConstant = false;
         }
@@ -26,8 +26,8 @@ bool isGlobalPropertyConstant(const Expression* expression, const T& properties)
     return isConstant;
 };
 
-bool isFeatureConstant(const Expression* expression);
-bool isZoomConstant(const Expression* e);
+bool isFeatureConstant(const Expression& expression);
+bool isZoomConstant(const Expression& e);
 
 
 } // namespace expression
diff --git a/include/mbgl/style/expression/let.hpp b/include/mbgl/style/expression/let.hpp
index 6c63e6ab64..aaa16ca0c2 100644
--- a/include/mbgl/style/expression/let.hpp
+++ b/include/mbgl/style/expression/let.hpp
@@ -24,7 +24,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&);
     
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>&) const override;
+    void eachChild(const std::function<void(const Expression&)>&) const override;
 
     bool operator==(const Expression& e) const override {
         if (auto rhs = dynamic_cast<const Let*>(&e)) {
@@ -53,7 +53,7 @@ public:
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>&) const override;
+    void eachChild(const std::function<void(const Expression&)>&) const override;
 
     bool operator==(const Expression& e) const override {
         if (auto rhs = dynamic_cast<const Var*>(&e)) {
diff --git a/include/mbgl/style/expression/literal.hpp b/include/mbgl/style/expression/literal.hpp
index 4a94aa9221..a0819c7e73 100644
--- a/include/mbgl/style/expression/literal.hpp
+++ b/include/mbgl/style/expression/literal.hpp
@@ -20,7 +20,7 @@ public:
     
     static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&);
 
-    void eachChild(const std::function<void(const Expression*)>&) const override {}
+    void eachChild(const std::function<void(const Expression&)>&) const override {}
     
     bool operator==(const Expression& e) const override {
         if (auto rhs = dynamic_cast<const Literal*>(&e)) {
diff --git a/include/mbgl/style/expression/match.hpp b/include/mbgl/style/expression/match.hpp
index 83b2764976..e17fe96bfe 100644
--- a/include/mbgl/style/expression/match.hpp
+++ b/include/mbgl/style/expression/match.hpp
@@ -25,7 +25,7 @@ public:
         otherwise(std::move(otherwise_))
     {}
 
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
 
diff --git a/include/mbgl/style/expression/step.hpp b/include/mbgl/style/expression/step.hpp
index 1884c75071..e3c49bc609 100644
--- a/include/mbgl/style/expression/step.hpp
+++ b/include/mbgl/style/expression/step.hpp
@@ -26,7 +26,7 @@ public:
     {}
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
-    void eachChild(const std::function<void(const Expression*)>& visit) const override;
+    void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     const std::unique_ptr<Expression>& getInput() const { return input; }
     Range<float> getCoveringStops(const double lower, const double upper) const;
diff --git a/include/mbgl/style/function/camera_function.hpp b/include/mbgl/style/function/camera_function.hpp
index 14a874cdfc..3391ec1523 100644
--- a/include/mbgl/style/function/camera_function.hpp
+++ b/include/mbgl/style/function/camera_function.hpp
@@ -33,8 +33,8 @@ public:
         : expression(std::move(expression_)),
           zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
     {
-        assert(!isZoomConstant(expression.get()));
-        assert(isFeatureConstant(expression.get()));
+        assert(!expression::isZoomConstant(*expression));
+        assert(expression::isFeatureConstant(*expression));
     }
 
     CameraFunction(Stops stops_)
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp
index 55bdaacd48..89b7a0a237 100644
--- a/include/mbgl/style/function/composite_function.hpp
+++ b/include/mbgl/style/function/composite_function.hpp
@@ -56,8 +56,8 @@ public:
     :   expression(std::move(expression_)),
         zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
     {
-        assert(!isZoomConstant(expression.get()));
-        assert(!isFeatureConstant(expression.get()));
+        assert(!expression::isZoomConstant(*expression));
+        assert(!expression::isFeatureConstant(*expression));
     }
 
     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 a16b37a13e..ed35b4bf14 100644
--- a/include/mbgl/style/function/convert.hpp
+++ b/include/mbgl/style/function/convert.hpp
@@ -35,7 +35,7 @@ namespace detail {
 class ErrorExpression : public Expression {
 public:
     ErrorExpression(std::string message_) : Expression(type::Error), message(std::move(message_)) {}
-    void eachChild(const std::function<void(const Expression*)>&) const override {}
+    void eachChild(const std::function<void(const Expression&)>&) const override {}
     
     bool operator==(const Expression& e) const override {
         return dynamic_cast<const ErrorExpression*>(&e);
diff --git a/include/mbgl/style/function/source_function.hpp b/include/mbgl/style/function/source_function.hpp
index 49018d2ddd..02e4b604e2 100644
--- a/include/mbgl/style/function/source_function.hpp
+++ b/include/mbgl/style/function/source_function.hpp
@@ -32,8 +32,8 @@ public:
     SourceFunction(std::unique_ptr<expression::Expression> expression_)
         : expression(std::move(expression_))
     {
-        assert(isZoomConstant(expression.get()));
-        assert(!isFeatureConstant(expression.get()));
+        assert(expression::isZoomConstant(*expression));
+        assert(!expression::isFeatureConstant(*expression));
     }
     
     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 bcbd62cfd0..8958d5c6c7 100644
--- a/platform/node/src/node_expression.cpp
+++ b/platform/node/src/node_expression.cpp
@@ -218,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(isFeatureConstant(expression.get())));
+    info.GetReturnValue().Set(Nan::New(isFeatureConstant(*expression)));
 }
 
 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(isZoomConstant(expression.get())));
+    info.GetReturnValue().Set(Nan::New(isZoomConstant(*expression)));
 }
 
 } // namespace node_mbgl
diff --git a/src/mbgl/style/expression/array_assertion.cpp b/src/mbgl/style/expression/array_assertion.cpp
index 8031868c9c..a62f67fbb5 100644
--- a/src/mbgl/style/expression/array_assertion.cpp
+++ b/src/mbgl/style/expression/array_assertion.cpp
@@ -21,8 +21,8 @@ EvaluationResult ArrayAssertion::evaluate(const EvaluationContext& params) const
     return *result;
 }
 
-void ArrayAssertion::eachChild(const std::function<void(const Expression*)>& visit) const {
-    visit(input.get());
+void ArrayAssertion::eachChild(const std::function<void(const Expression&)>& visit) const {
+    visit(*input);
 }
 
 using namespace mbgl::style::conversion;
diff --git a/src/mbgl/style/expression/assertion.cpp b/src/mbgl/style/expression/assertion.cpp
index 3e57377ece..a17c53cf54 100644
--- a/src/mbgl/style/expression/assertion.cpp
+++ b/src/mbgl/style/expression/assertion.cpp
@@ -53,9 +53,9 @@ EvaluationResult Assertion::evaluate(const EvaluationContext& params) const {
     return EvaluationError { "Unreachable" };
 };
 
-void Assertion::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Assertion::eachChild(const std::function<void(const Expression&)>& visit) const {
     for(const std::unique_ptr<Expression>& input : inputs) {
-        visit(input.get());
+        visit(*input);
     }
 };
 
diff --git a/src/mbgl/style/expression/at.cpp b/src/mbgl/style/expression/at.cpp
index ffe7cae1c7..d9beb63b52 100644
--- a/src/mbgl/style/expression/at.cpp
+++ b/src/mbgl/style/expression/at.cpp
@@ -32,9 +32,9 @@ EvaluationResult At::evaluate(const EvaluationContext& params) const {
     return inputArray[static_cast<std::size_t>(i)];
 }
 
-void At::eachChild(const std::function<void(const Expression*)>& visit) const {
-    visit(index.get());
-    visit(input.get());
+void At::eachChild(const std::function<void(const Expression&)>& visit) const {
+    visit(*index);
+    visit(*input);
 }
 
 using namespace mbgl::style::conversion;
diff --git a/src/mbgl/style/expression/boolean_operator.cpp b/src/mbgl/style/expression/boolean_operator.cpp
index b5e1c39683..88797f965a 100644
--- a/src/mbgl/style/expression/boolean_operator.cpp
+++ b/src/mbgl/style/expression/boolean_operator.cpp
@@ -13,9 +13,9 @@ EvaluationResult Any::evaluate(const EvaluationContext& params) const {
     return EvaluationResult(false);
 }
 
-void Any::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Any::eachChild(const std::function<void(const Expression&)>& visit) const {
     for (const std::unique_ptr<Expression>& input : inputs) {
-        visit(input.get());
+        visit(*input);
     }
 }
 
@@ -36,9 +36,9 @@ EvaluationResult All::evaluate(const EvaluationContext& params) const {
     return EvaluationResult(true);
 }
 
-void All::eachChild(const std::function<void(const Expression*)>& visit) const {
+void All::eachChild(const std::function<void(const Expression&)>& visit) const {
     for (const std::unique_ptr<Expression>& input : inputs) {
-        visit(input.get());
+        visit(*input);
     }
 }
 
diff --git a/src/mbgl/style/expression/case.cpp b/src/mbgl/style/expression/case.cpp
index 54175cba9a..a435b71fc5 100644
--- a/src/mbgl/style/expression/case.cpp
+++ b/src/mbgl/style/expression/case.cpp
@@ -18,12 +18,12 @@ EvaluationResult Case::evaluate(const EvaluationContext& params) const {
     return otherwise->evaluate(params);
 }
 
-void Case::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Case::eachChild(const std::function<void(const Expression&)>& visit) const {
     for (const Branch& branch : branches) {
-        visit(branch.first.get());
-        visit(branch.second.get());
+        visit(*branch.first);
+        visit(*branch.second);
     }
-    visit(otherwise.get());
+    visit(*otherwise);
 }
 
 bool Case::operator==(const Expression& e) const {
diff --git a/src/mbgl/style/expression/coalesce.cpp b/src/mbgl/style/expression/coalesce.cpp
index 72097c5bf4..bfde3c7581 100644
--- a/src/mbgl/style/expression/coalesce.cpp
+++ b/src/mbgl/style/expression/coalesce.cpp
@@ -13,9 +13,9 @@ EvaluationResult Coalesce::evaluate(const EvaluationContext& params) const {
     return result;
 }
 
-void Coalesce::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Coalesce::eachChild(const std::function<void(const Expression&)>& visit) const {
     for (const std::unique_ptr<Expression>& arg : args) {
-        visit(arg.get());
+        visit(*arg);
     }
 }
 
diff --git a/src/mbgl/style/expression/coercion.cpp b/src/mbgl/style/expression/coercion.cpp
index 9945d8d3d9..f2042ffd8f 100644
--- a/src/mbgl/style/expression/coercion.cpp
+++ b/src/mbgl/style/expression/coercion.cpp
@@ -122,9 +122,9 @@ EvaluationResult Coercion::evaluate(const EvaluationContext& params) const {
     return EvaluationError { "Unreachable" };
 };
 
-void Coercion::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Coercion::eachChild(const std::function<void(const Expression&)>& visit) const {
     for(const std::unique_ptr<Expression>& input : inputs) {
-        visit(input.get());
+        visit(*input);
     }
 };
 
diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp
index 0794c90a3c..0ebb37faa9 100644
--- a/src/mbgl/style/expression/is_constant.cpp
+++ b/src/mbgl/style/expression/is_constant.cpp
@@ -4,8 +4,8 @@ namespace mbgl {
 namespace style {
 namespace expression {
 
-bool isFeatureConstant(const Expression* expression) {
-    if (auto e = dynamic_cast<const CompoundExpressionBase*>(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) {
@@ -22,7 +22,7 @@ bool isFeatureConstant(const Expression* expression) {
     }
 
     bool featureConstant = true;
-    expression->eachChild([&](const Expression* e) {
+    expression.eachChild([&](const Expression& e) {
         if (featureConstant && !isFeatureConstant(e)) {
             featureConstant = false;
         }
@@ -30,7 +30,7 @@ bool isFeatureConstant(const Expression* expression) {
     return featureConstant;
 }
 
-bool isZoomConstant(const Expression* e) {
+bool isZoomConstant(const Expression& e) {
     return isGlobalPropertyConstant(e, std::array<std::string, 1>{{"zoom"}});
 }
 
diff --git a/src/mbgl/style/expression/let.cpp b/src/mbgl/style/expression/let.cpp
index daebf5dd08..8e206d3582 100644
--- a/src/mbgl/style/expression/let.cpp
+++ b/src/mbgl/style/expression/let.cpp
@@ -9,11 +9,11 @@ EvaluationResult Let::evaluate(const EvaluationContext& params) const {
     return result->evaluate(params);
 }
 
-void Let::eachChild(const std::function<void(const Expression*)>& visit) const {
+void Let::eachChild(const std::function<void(const Expression&)>& visit) const {
     for (auto it = bindings.begin(); it != bindings.end(); it++) {
-        visit(it->second.get());
+        visit(*it->second);
     }
-    visit(result.get());
+    visit(*result);
 }
 
 using namespace mbgl::style::conversion;
@@ -64,7 +64,7 @@ EvaluationResult Var::evaluate(const EvaluationContext& params) const {
     return value->evaluate(params);
 }
 
-void Var::eachChild(const std::function<void(const Expression*)>&) const {}
+void Var::eachChild(const std::function<void(const Expression&)>&) const {}
 
 ParseResult Var::parse(const Convertible& value_, ParsingContext& ctx) {
     assert(isArray(value_));
diff --git a/src/mbgl/style/expression/match.cpp b/src/mbgl/style/expression/match.cpp
index aef022cffa..6336eba1e6 100644
--- a/src/mbgl/style/expression/match.cpp
+++ b/src/mbgl/style/expression/match.cpp
@@ -7,12 +7,12 @@ namespace style {
 namespace expression {
 
 template <typename T>
-void Match<T>::eachChild(const std::function<void(const Expression*)>& visit) const {
-    visit(input.get());
+void Match<T>::eachChild(const std::function<void(const Expression&)>& visit) const {
+    visit(*input);
     for (const std::pair<T, std::shared_ptr<Expression>>& branch : branches) {
-        visit(branch.second.get());
+        visit(*branch.second);
     }
-    visit(otherwise.get());
+    visit(*otherwise);
 }
 
 template <typename T>
diff --git a/src/mbgl/style/expression/parsing_context.cpp b/src/mbgl/style/expression/parsing_context.cpp
index 46d5942c70..4928edc92a 100644
--- a/src/mbgl/style/expression/parsing_context.cpp
+++ b/src/mbgl/style/expression/parsing_context.cpp
@@ -25,20 +25,20 @@ namespace mbgl {
 namespace style {
 namespace expression {
 
-bool isConstant(const Expression* expression) {
-    if (dynamic_cast<const Var*>(expression)) {
+bool isConstant(const Expression& expression) {
+    if (dynamic_cast<const Var*>(&expression)) {
         return false;
     }
     
-    if (auto compound = dynamic_cast<const CompoundExpressionBase*>(expression)) {
+    if (auto compound = dynamic_cast<const CompoundExpressionBase*>(&expression)) {
         if (compound->getName() == "error") {
             return false;
         }
     }
     
     bool literalArgs = true;
-    expression->eachChild([&](const Expression* child) {
-        if (!dynamic_cast<const Literal*>(child)) {
+    expression.eachChild([&](const Expression& child) {
+        if (!dynamic_cast<const Literal*>(&child)) {
             literalArgs = false;
         }
     });
@@ -154,7 +154,7 @@ ParseResult ParsingContext::parse(const Convertible& value)
     // If an expression's arguments are all literals, we can evaluate
     // it immediately and replace it with a literal value in the
     // parsed result.
-    if (parsed && !dynamic_cast<Literal *>(parsed->get()) && isConstant(parsed->get())) {
+    if (parsed && !dynamic_cast<Literal *>(parsed->get()) && isConstant(**parsed)) {
         EvaluationContext params(nullptr);
         EvaluationResult evaluated((*parsed)->evaluate(params));
         if (!evaluated) {
diff --git a/src/mbgl/style/expression/step.cpp b/src/mbgl/style/expression/step.cpp
index 0ab67f8598..2720e9257a 100644
--- a/src/mbgl/style/expression/step.cpp
+++ b/src/mbgl/style/expression/step.cpp
@@ -25,10 +25,10 @@ EvaluationResult Step::evaluate(const EvaluationContext& params) const {
     }
 }
 
-void Step::eachChild(const std::function<void(const Expression*)>& visit) const {
-    visit(input.get());
+void Step::eachChild(const std::function<void(const Expression&)>& visit) const {
+    visit(*input);
     for (auto it = stops.begin(); it != stops.end(); it++) {
-        visit(it->second.get());
+        visit(*it->second);
     }
 }