use rvalue references for constructor parameters in various expression structs

NP-1167

Author: casperlamboo

include/cura-formulae-engine/ast/binary_expr/binary_expr.h

@@ -12,7 +12,7 @@ struct BinaryExpr : Expr
     ExprPtr lhs;
     ExprPtr rhs;
 
-    BinaryExpr(ExprPtr lhs, ExprPtr rhs)
+    BinaryExpr(ExprPtr&& lhs, ExprPtr&& rhs)
         : lhs(std::move(lhs))
         , rhs(std::move(rhs))
     {

include/cura-formulae-engine/ast/condition_expr.h

@@ -12,7 +12,7 @@ struct ConditionExpr final : Expr
     ExprPtr condition;
     ExprPtr else_expr;
 
-    ConditionExpr(ExprPtr then_expr, ExprPtr condition, ExprPtr else_expr)
+    ConditionExpr(ExprPtr&& then_expr, ExprPtr&& condition, ExprPtr&& else_expr)
         : then_expr(std::move(then_expr))
         , condition(std::move(condition))
         , else_expr(std::move(else_expr))

include/cura-formulae-engine/ast/expr_ptr.h

@@ -16,7 +16,7 @@ struct ExprPtr final : Expr
 
     std::unique_ptr<Expr> ptr;
 
-    ExprPtr(std::unique_ptr<Expr> ptr)
+    ExprPtr(std::unique_ptr<Expr>&& ptr)
         : ptr(std::move(ptr))
     {
     }

include/cura-formulae-engine/ast/fn_application_expr.h

@@ -23,7 +23,7 @@ struct FnApplicationExpr final : Expr
     std::vector<ExprPtr> args;
     std::vector<KeywordArg> kwargs;
 
-    FnApplicationExpr(ExprPtr fn, std::vector<ExprPtr>&& args, std::vector<KeywordArg>&& kwargs = {})
+    FnApplicationExpr(ExprPtr&& fn, std::vector<ExprPtr>&& args, std::vector<KeywordArg>&& kwargs = {})
         : fn(std::move(fn))
         , args(std::move(args))
         , kwargs(std::move(kwargs))

include/cura-formulae-engine/ast/index_expr.h

@@ -19,7 +19,7 @@ struct IndexExpr final : Expr
     ExprPtr array;
     ExprPtr index;
 
-    IndexExpr(ExprPtr array, ExprPtr index)
+    IndexExpr(ExprPtr&& array, ExprPtr&& index)
         : array(std::move(array))
         , index(std::move(index))
     {

include/cura-formulae-engine/ast/list_comprehension_expr.h

@@ -21,7 +21,7 @@ struct ListComprehensionExpr final : Expr
         ExprPtr iterable;
         std::vector<ExprPtr> conditions;
 
-        loop(ExprPtr iterator_key, ExprPtr iterable, std::vector<ExprPtr> conditions)
+        loop(ExprPtr&& iterator_key, ExprPtr&& iterable, std::vector<ExprPtr>&& conditions)
             : iterator_key(std::move(iterator_key))
             , iterable(std::move(iterable))
             , conditions(std::move(conditions))
@@ -32,7 +32,7 @@ struct ListComprehensionExpr final : Expr
     ExprPtr iterator;
     std::vector<loop> loops;
 
-    ListComprehensionExpr(ExprPtr iterator, std::vector<loop> loops)
+    ListComprehensionExpr(ExprPtr&& iterator, std::vector<loop>&& loops)
         : iterator(std::move(iterator))
         , loops(std::move(loops))
     {

include/cura-formulae-engine/ast/list_expr.h

@@ -13,7 +13,7 @@ struct ListExpr final : Expr
 {
     std::vector<ExprPtr> elements;
 
-    ListExpr(std::vector<ExprPtr> elements)
+    ListExpr(std::vector<ExprPtr>&& elements)
         : elements(std::move(elements))
     {
     }

include/cura-formulae-engine/ast/property_access_expr.h

@@ -13,7 +13,7 @@ struct PropertyAccessExpr final : Expr
     ExprPtr object;
     std::string property;
 
-    PropertyAccessExpr(ExprPtr object, std::string property)
+    PropertyAccessExpr(ExprPtr&& object, std::string&& property)
         : object(std::move(object))
         , property(std::move(property))
     {

include/cura-formulae-engine/ast/slice_expr.h

@@ -23,7 +23,7 @@ struct SliceExpr final : Expr
     std::optional<ExprPtr> end_index;
     std::optional<ExprPtr> step_size;
 
-    SliceExpr(ExprPtr array, std::optional<ExprPtr> start_index, std::optional<ExprPtr> end_index, std::optional<ExprPtr> step_size)
+    SliceExpr(ExprPtr&& array, std::optional<ExprPtr>&& start_index, std::optional<ExprPtr>&& end_index, std::optional<ExprPtr>&& step_size)
         : array(std::move(array))
         , start_index(std::move(start_index))
         , end_index(std::move(end_index))

include/cura-formulae-engine/ast/tuple_expr.h

@@ -15,7 +15,7 @@ struct TupleExpr final : Expr
 {
     std::vector<ExprPtr> elements;
 
-    TupleExpr(std::vector<ExprPtr> elements)
+    TupleExpr(std::vector<ExprPtr>&& elements)
         : elements(std::move(elements))
     {
     }