Include name in CompoundExpression

3 files changed, 49 insertions, 28 deletions

diff --git a/include/mbgl/style/expression/compound_expression.hpp b/include/mbgl/style/expression/compound_expression.hpp
index c09edaeea8..d5f2540428 100644
--- a/include/mbgl/style/expression/compound_expression.hpp
+++ b/include/mbgl/style/expression/compound_expression.hpp
@@ -36,7 +36,7 @@ struct SignatureBase {
         params(params_)
     {}
     virtual ~SignatureBase() {}
-    virtual std::unique_ptr<Expression> makeExpression(std::vector<std::unique_ptr<Expression>>) const = 0;
+    virtual std::unique_ptr<Expression> makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>>) const = 0;
     type::Type result;
     variant<std::vector<type::Type>, VarargsType> params;
 };
@@ -63,7 +63,7 @@ struct Signature<R (const EvaluationParameters&, Params...)> : SignatureBase {
         zoomConstant(isZoomConstant_)
     {}
     
-    std::unique_ptr<Expression> makeExpression(std::vector<std::unique_ptr<Expression>> args) const override;
+    std::unique_ptr<Expression> makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const override;
     
     bool isFeatureConstant() const { return featureConstant; }
     bool isZoomConstant() const { return zoomConstant; }
@@ -104,7 +104,7 @@ struct Signature<R (const Varargs<T>&)> : SignatureBase {
         evaluate(evaluate_)
     {}
     
-    std::unique_ptr<Expression> makeExpression(std::vector<std::unique_ptr<Expression>> args) const override;
+    std::unique_ptr<Expression> makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const override;
     
     bool isFeatureConstant() const { return true; }
     bool isZoomConstant() const { return true; }
@@ -143,7 +143,7 @@ struct Signature<R (Params...)> : SignatureBase {
         return applyImpl(evaluationParameters, args, std::index_sequence_for<Params...>{});
     }
     
-    std::unique_ptr<Expression> makeExpression(std::vector<std::unique_ptr<Expression>> args) const override;
+    std::unique_ptr<Expression> makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const override;
     
     R (*evaluate)(Params...);
 private:
@@ -180,14 +180,29 @@ struct Signature<Lambda, std::enable_if_t<std::is_class<Lambda>::value>>
     : Signature<decltype(&Lambda::operator())>
 { using Signature<decltype(&Lambda::operator())>::Signature; };
 
+class CompoundExpressionBase : public Expression {
+public:
+    CompoundExpressionBase(const std::string& name_, type::Type type) :
+        Expression(type),
+        name(name_)
+    {}
+    
+    std::string getName() { return name; }
+    
+    virtual ~CompoundExpressionBase();
+private:
+    std::string name;
+};
+
 template <typename Signature>
-class CompoundExpression : public Expression {
+class CompoundExpression : public CompoundExpressionBase {
 public:
     using Args = typename Signature::Args;
     
-    CompoundExpression(Signature signature_,
+    CompoundExpression(const std::string& name,
+                       Signature signature_,
                        typename Signature::Args args_) :
-        Expression(signature_.result),
+        CompoundExpressionBase(name, signature_.result),
         signature(signature_),
         args(std::move(args_))
     {}
@@ -254,10 +269,18 @@ struct CompoundExpressions {
             args.push_back(std::move(*parsed));
         }
         
-        return create(definition, std::move(args), ctx);
+        return create(*name, definition, std::move(args), ctx);
+    }
+    
+    static ParseResult create(const std::string& name,
+                              std::vector<std::unique_ptr<Expression>> args,
+                              ParsingContext ctx)
+    {
+        return create(name, definitions.at(name), std::move(args), ctx);
     }
     
-    static ParseResult create(const Definition& definition,
+    static ParseResult create(const std::string& name,
+                              const Definition& definition,
                               std::vector<std::unique_ptr<Expression>> args,
                               ParsingContext ctx)
     {
@@ -293,7 +316,7 @@ struct CompoundExpressions {
             }
             
             if (currentSignatureErrors.size() == 0) {
-                return ParseResult(signature->makeExpression(std::move(args)));
+                return ParseResult(signature->makeExpression(name, std::move(args)));
             }
         }
         
diff --git a/include/mbgl/style/function/convert.hpp b/include/mbgl/style/function/convert.hpp
index dc44807a18..4e57c5eb29 100644
--- a/include/mbgl/style/function/convert.hpp
+++ b/include/mbgl/style/function/convert.hpp
@@ -54,22 +54,16 @@ struct Convert {
     static std::unique_ptr<Expression> makeGet(const std::string& type, const std::string& property, ParsingContext ctx) {
         std::vector<std::unique_ptr<Expression>> getArgs;
         getArgs.push_back(makeLiteral(property));
-        ParseResult get = CompoundExpressions::create(CompoundExpressions::definitions.at("get"),
-                                                      std::move(getArgs),
-                                                      ctx);
+        ParseResult get = CompoundExpressions::create("get", std::move(getArgs), ctx);
 
         std::vector<std::unique_ptr<Expression>> assertionArgs;
         assertionArgs.push_back(std::move(*get));
         
-        return std::move(*(CompoundExpressions::create(CompoundExpressions::definitions.at(type),
-                                                       std::move(assertionArgs),
-                                                       ctx)));
+        return std::move(*(CompoundExpressions::create(type, std::move(assertionArgs), ctx)));
     }
     
     static std::unique_ptr<Expression> makeZoom(ParsingContext ctx) {
-        return std::move(*(CompoundExpressions::create(CompoundExpressions::definitions.at("zoom"),
-                                                       std::vector<std::unique_ptr<Expression>>(),
-                                                       ctx)));
+        return std::move(*(CompoundExpressions::create("zoom", std::vector<std::unique_ptr<Expression>>(), ctx)));
     }
     
     static std::unique_ptr<Expression> makeError(std::string message) {
@@ -297,9 +291,7 @@ struct Convert {
             [&] (const type::Array& arr) {
                 std::vector<std::unique_ptr<Expression>> getArgs;
                 getArgs.push_back(makeLiteral(property));
-                ParseResult get = CompoundExpressions::create(CompoundExpressions::definitions.at("get"),
-                                                              std::move(getArgs),
-                                                              ParsingContext(errors));
+                ParseResult get = CompoundExpressions::create("get", std::move(getArgs), ParsingContext(errors));
                 return std::make_unique<ArrayAssertion>(arr, std::move(*get));
             },
             [&] (const auto&) -> std::unique_ptr<Expression> {
diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp
index 1821200fe6..f815d4747d 100644
--- a/src/mbgl/style/expression/compound_expression.cpp
+++ b/src/mbgl/style/expression/compound_expression.cpp
@@ -14,23 +14,29 @@ namespace detail {
     }
 } // namespace detail
 
+CompoundExpressionBase::~CompoundExpressionBase() {};
+
 template <class R, class... Params>
-std::unique_ptr<Expression> Signature<R (const EvaluationParameters&, Params...)>::makeExpression(std::vector<std::unique_ptr<Expression>> args) const {
+std::unique_ptr<Expression> Signature<R (const EvaluationParameters&, Params...)>
+::makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const
+{
     typename Signature::Args argsArray;
     std::copy_n(std::make_move_iterator(args.begin()), sizeof...(Params), argsArray.begin());
-    return std::make_unique<CompoundExpression<Signature>>(*this, std::move(argsArray));
+    return std::make_unique<CompoundExpression<Signature>>(name, *this, std::move(argsArray));
 };
 
 template <typename R, typename T>
-std::unique_ptr<Expression> Signature<R (const Varargs<T>&)>::makeExpression(std::vector<std::unique_ptr<Expression>> args) const {
-    return std::make_unique<CompoundExpression<Signature>>(*this, std::move(args));
+std::unique_ptr<Expression> Signature<R (const Varargs<T>&)>
+::makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const {
+    return std::make_unique<CompoundExpression<Signature>>(name, *this, std::move(args));
 };
 
 template <class R, class... Params>
-std::unique_ptr<Expression> Signature<R (Params...)>::makeExpression(std::vector<std::unique_ptr<Expression>> args) const {
+std::unique_ptr<Expression> Signature<R (Params...)>
+::makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>> args) const {
     typename Signature::Args argsArray;
     std::copy_n(std::make_move_iterator(args.begin()), sizeof...(Params), argsArray.begin());
-    return std::make_unique<CompoundExpression<Signature>>(*this, std::move(argsArray));
+    return std::make_unique<CompoundExpression<Signature>>(name, *this, std::move(argsArray));
 };
 
 using Definition = CompoundExpressions::Definition;