Make evaluation of macro call params at the point of call instead of point of macro definition

Author: flexferrum

src/expression_evaluator.cpp

@@ -87,7 +87,7 @@ BinaryExpression::BinaryExpression(BinaryExpression::Operation oper, ExpressionE
 {
     if (m_oper == In)
     {
-        CallParams params;
+        CallParamsInfo params;
         params.kwParams["seq"] = rightExpr;
         m_inTester = CreateTester("in", params);
     }
@@ -185,7 +185,7 @@ InternalValue DictCreator::Evaluate(RenderContext& context)
     return CreateMapAdapter(std::move(result));;
 }
 
-ExpressionFilter::ExpressionFilter(const std::string& filterName, CallParams params)
+ExpressionFilter::ExpressionFilter(const std::string& filterName, CallParamsInfo params)
 {
     m_filter = CreateFilter(filterName, std::move(params));
     if (!m_filter)
@@ -200,7 +200,7 @@ InternalValue ExpressionFilter::Evaluate(const InternalValue& baseVal, RenderCon
     return m_filter->Filter(baseVal, context);
 }
 
-IsExpression::IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParams params)
+IsExpression::IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParamsInfo params)
     : m_value(value)
 {
     m_tester = CreateTester(tester, std::move(params));
@@ -268,13 +268,15 @@ void CallExpression::Render(OutStream& stream, RenderContext& values)
         }
     }
 
+    auto callParams = helpers::EvaluateCallParams(m_params, values);
+
     if (callable->GetType() == Callable::Type::Expression)
     {
-        stream.WriteValue(callable->GetExpressionCallable()(m_params, values));
+        stream.WriteValue(callable->GetExpressionCallable()(callParams, values));
     }
     else
     {
-        callable->GetStatementCallable()(m_params, stream, values);
+        callable->GetStatementCallable()(callParams, stream, values);
     }
 }
 
@@ -294,22 +296,24 @@ InternalValue CallExpression::CallArbitraryFn(RenderContext& values)
     if (kind != Callable::GlobalFunc && kind != Callable::UserCallable && kind != Callable::Macro)
         return InternalValue();
 
+    auto callParams = helpers::EvaluateCallParams(m_params, values);
+
     if (callable->GetType() == Callable::Type::Expression)
     {
-        return callable->GetExpressionCallable()(m_params, values);
+        return callable->GetExpressionCallable()(callParams, values);
     }
 
     TargetString resultStr;
     auto stream = values.GetRendererCallback()->GetStreamOnString(resultStr);
-    callable->GetStatementCallable()(m_params, stream, values);
+    callable->GetStatementCallable()(callParams, stream, values);
     return resultStr;
 }
 
 InternalValue CallExpression::CallGlobalRange(RenderContext& values)
 {
     bool isArgsParsed = true;
 
-    auto args = helpers::ParseCallParams({{"start"}, {"stop", true}, {"step"}}, m_params, isArgsParsed);
+    auto args = helpers::ParseCallParamsInfo({ { "start" }, { "stop", true }, { "step" } }, m_params, isArgsParsed);
     if (!isArgsParsed)
         return InternalValue();
 
@@ -385,8 +389,23 @@ enum ParamState
     MappedKw,
 };
 
-template<typename T>
-ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, bool& isSucceeded)
+template<typename Result>
+struct ParsedArgumentDefaultValGetter;
+
+template<>
+struct ParsedArgumentDefaultValGetter<ParsedArguments>
+{
+    static auto Get(const InternalValue& val) { return val; }
+};
+
+template<>
+struct ParsedArgumentDefaultValGetter<ParsedArgumentsInfo>
+{
+    static auto Get(const InternalValue& val) { return std::make_shared<ConstantExpression>(val); }
+};
+
+template<typename Result, typename T, typename P>
+Result ParseCallParamsImpl(const T& args, const P& params, bool& isSucceeded)
 {
     struct ArgInfo
     {
@@ -401,7 +420,7 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
 
     isSucceeded = true;
 
-    ParsedArguments result;
+    Result result;
 
     int argIdx = 0;
     int firstMandatoryIdx = -1;
@@ -465,6 +484,8 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
                 ;
 
             isFirstTime = false;
+            if (startPosArg == args.size())
+                break;
             continue;
         }
 
@@ -510,7 +531,14 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
         case NotFound:
         {
             if (!IsEmpty(argInfo.info->defaultVal))
-                result.args[argInfo.info->name] = std::make_shared<ConstantExpression>(argInfo.info->defaultVal);
+#if __cplusplus >= 201703L
+                if constexpr (std::is_same<Result, ParsedArgumentsInfo>::value)
+                    result.args[argInfo.info->name] = std::make_shared<ConstantExpression>(argInfo.info->defaultVal);
+                else
+                    result.args[argInfo.info->name] = argInfo.info->defaultVal;
+#else
+                result.args[argInfo.info->name] = ParsedArgumentDefaultValGetter<Result>::Get(argInfo.info->defaultVal);
+#endif
             break;
         }
         case NotFoundMandatory:
@@ -537,12 +565,35 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
 
 ParsedArguments ParseCallParams(const std::initializer_list<ArgumentInfo>& args, const CallParams& params, bool& isSucceeded)
 {
-    return ParseCallParamsImpl(args, params, isSucceeded);
+    return ParseCallParamsImpl<ParsedArguments>(args, params, isSucceeded);
 }
 
 ParsedArguments ParseCallParams(const std::vector<ArgumentInfo>& args, const CallParams& params, bool& isSucceeded)
 {
-    return ParseCallParamsImpl(args, params, isSucceeded);
+    return ParseCallParamsImpl<ParsedArguments>(args, params, isSucceeded);
+}
+
+ParsedArgumentsInfo ParseCallParamsInfo(const std::initializer_list<ArgumentInfo>& args, const CallParamsInfo& params, bool& isSucceeded)
+{
+    return ParseCallParamsImpl<ParsedArgumentsInfo>(args, params, isSucceeded);
+}
+
+ParsedArgumentsInfo ParseCallParamsInfo(const std::vector<ArgumentInfo>& args, const CallParamsInfo& params, bool& isSucceeded)
+{
+    return ParseCallParamsImpl<ParsedArgumentsInfo>(args, params, isSucceeded);
+}
+
+CallParams EvaluateCallParams(const CallParamsInfo& info, RenderContext& context)
+{
+    CallParams result;
+
+    for (auto& p : info.posParams)
+        result.posParams.push_back(p->Evaluate(context));
+
+    for (auto& kw : info.kwParams)
+        result.kwParams[kw.first] = kw.second->Evaluate(context);
+
+    return result;
 }
 
 }

src/expression_evaluator.h

@@ -31,6 +31,12 @@ using ExpressionEvaluatorPtr = std::shared_ptr<T>;
 using Expression = ExpressionEvaluatorBase;
 
 struct CallParams
+{
+    std::unordered_map<std::string, InternalValue> kwParams;
+    std::vector<InternalValue> posParams;
+};
+
+struct CallParamsInfo
 {
     std::unordered_map<std::string, ExpressionEvaluatorPtr<>> kwParams;
     std::vector<ExpressionEvaluatorPtr<>> posParams;
@@ -50,7 +56,7 @@ struct ArgumentInfo
     }
 };
 
-struct ParsedArguments
+struct ParsedArgumentsInfo
 {
     std::unordered_map<std::string, ExpressionEvaluatorPtr<>> args;
     std::unordered_map<std::string, ExpressionEvaluatorPtr<>> extraKwArgs;
@@ -66,6 +72,22 @@ struct ParsedArguments
     }
 };
 
+struct ParsedArguments
+{
+    std::unordered_map<std::string, InternalValue> args;
+    std::unordered_map<std::string, InternalValue> extraKwArgs;
+    std::vector<InternalValue> extraPosArgs;
+
+    InternalValue operator[](const std::string& name) const
+    {
+        auto p = args.find(name);
+        if (p == args.end())
+            return InternalValue();
+
+        return p->second;
+    }
+};
+
 class ExpressionFilter;
 class IfExpression;
 
@@ -219,9 +241,9 @@ class IsExpression : public Expression
         virtual bool Test(const InternalValue& baseVal, RenderContext& context) = 0;
     };
 
-    using TesterFactoryFn = std::function<std::shared_ptr<ITester> (CallParams params)>;
+    using TesterFactoryFn = std::function<std::shared_ptr<ITester>(CallParamsInfo params)>;
 
-    IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParams params);
+    IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParamsInfo params);
     InternalValue Evaluate(RenderContext& context) override;
 
 private:
@@ -275,7 +297,7 @@ class CallExpression : public Expression
 public:
     virtual ~CallExpression() {}
 
-    CallExpression(ExpressionEvaluatorPtr<> valueRef, CallParams params)
+    CallExpression(ExpressionEvaluatorPtr<> valueRef, CallParamsInfo params)
         : m_valueRef(std::move(valueRef))
         , m_params(std::move(params))
     {
@@ -294,7 +316,7 @@ class CallExpression : public Expression
 
 private:
     ExpressionEvaluatorPtr<> m_valueRef;
-    CallParams m_params;
+    CallParamsInfo m_params;
 };
 
 class ExpressionFilter
@@ -308,9 +330,9 @@ class ExpressionFilter
         virtual InternalValue Filter(const InternalValue& baseVal, RenderContext& context) = 0;
     };
 
-    using FilterFactoryFn = std::function<std::shared_ptr<IExpressionFilter> (CallParams params)>;
+    using FilterFactoryFn = std::function<std::shared_ptr<IExpressionFilter>(CallParamsInfo params)>;
 
-    ExpressionFilter(const std::string& filterName, CallParams params);
+    ExpressionFilter(const std::string& filterName, CallParamsInfo params);
 
     InternalValue Evaluate(const InternalValue& baseVal, RenderContext& context);
     void SetParentFilter(std::shared_ptr<ExpressionFilter> parentFilter)
@@ -351,6 +373,9 @@ namespace helpers
 {
 ParsedArguments ParseCallParams(const std::initializer_list<ArgumentInfo>& argsInfo, const CallParams& params, bool& isSucceeded);
 ParsedArguments ParseCallParams(const std::vector<ArgumentInfo>& args, const CallParams& params, bool& isSucceeded);
+ParsedArgumentsInfo ParseCallParamsInfo(const std::initializer_list<ArgumentInfo>& argsInfo, const CallParamsInfo& params, bool& isSucceeded);
+ParsedArgumentsInfo ParseCallParamsInfo(const std::vector<ArgumentInfo>& args, const CallParamsInfo& params, bool& isSucceeded);
+CallParams EvaluateCallParams(const CallParamsInfo& info, RenderContext& context);
 }
 } // jinja2
 

src/expression_parser.cpp

@@ -140,8 +140,8 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<Expression>> ExpressionPars
                 return MakeParseError(ErrorCode::ExpectedIdentifier, nextTok);
 
             std::string name = AsString(nextTok.value);
-            ParseResult<CallParams> params;
-    
+            ParseResult<CallParamsInfo> params;
+
             if (lexer.EatIfEqual('('))
                 params = ParseCallParams(lexer);
 
@@ -435,7 +435,7 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<Expression>> ExpressionPars
 {
     ExpressionEvaluatorPtr<Expression> result;
 
-    ParseResult<CallParams> params = ParseCallParams(lexer);
+    ParseResult<CallParamsInfo> params = ParseCallParams(lexer);
     if (!params)
         return params.get_unexpected();
 
@@ -444,9 +444,9 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<Expression>> ExpressionPars
     return result;
 }
 
-ExpressionParser::ParseResult<CallParams> ExpressionParser::ParseCallParams(LexScanner& lexer)
+ExpressionParser::ParseResult<CallParamsInfo> ExpressionParser::ParseCallParams(LexScanner& lexer)
 {
-    CallParams result;
+    CallParamsInfo result;
 
     if (lexer.EatIfEqual(')'))
         return result;
@@ -534,7 +534,7 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<ExpressionFilter>> Expressi
                 return MakeParseError(ErrorCode::ExpectedIdentifier, tok);
 
             std::string name = AsString(tok.value);
-            ParseResult<CallParams> params;
+            ParseResult<CallParamsInfo> params;
 
             if (lexer.NextToken() == '(')
                 params = ParseCallParams(lexer);

src/expression_parser.h

@@ -20,7 +20,7 @@ class ExpressionParser
     explicit ExpressionParser(const Settings& settings, TemplateEnv* env = nullptr);
     ParseResult<RendererPtr> Parse(LexScanner& lexer);
     ParseResult<ExpressionEvaluatorPtr<FullExpressionEvaluator>> ParseFullExpression(LexScanner& lexer, bool includeIfPart = true);
-    ParseResult<CallParams> ParseCallParams(LexScanner& lexer);
+    ParseResult<CallParamsInfo> ParseCallParams(LexScanner& lexer);
     ParseResult<ExpressionEvaluatorPtr<ExpressionFilter>> ParseFilterExpression(LexScanner& lexer);
 private:
     ParseResult<ExpressionEvaluatorPtr<Expression>> ParseLogicalNot(LexScanner& lexer);