Avoid dependency on `source lifetime. (#43)

This allows holding onto objects, caching results etc easily.
However it does introduce the overhead of ref counting.

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>

src/builtins/aggregates.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_numeric};
 use crate::lexer::Span;
@@ -20,7 +20,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("sum", (sum, 1));
 }
 
-fn count(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn count(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "count", params, args, 1)?;
 
     Ok(Value::from_float(match &args[0] {
@@ -37,7 +37,7 @@ fn count(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn max(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn max(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "max", params, args, 1)?;
 
     Ok(match &args[0] {
@@ -52,7 +52,7 @@ fn max(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn min(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn min(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "min", params, args, 1)?;
 
     Ok(match &args[0] {
@@ -67,7 +67,7 @@ fn min(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn product(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn product(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "product", params, args, 1)?;
 
     let mut v = 1 as Float;
@@ -92,7 +92,7 @@ fn product(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn sort(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn sort(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "sort", params, args, 1)?;
     Ok(match &args[0] {
         Value::Array(a) => {
@@ -109,7 +109,7 @@ fn sort(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn sum(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn sum(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "sum", params, args, 1)?;
 
     let mut v = 0 as Float;

src/builtins/arrays.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_array, ensure_numeric};
 use crate::lexer::Span;
@@ -18,7 +18,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("array.slice", (slice, 3));
 }
 
-fn concat(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "array.concat";
     ensure_args_count(span, name, params, args, 2)?;
     let mut v1 = ensure_array(name, &params[0], args[0].clone())?;
@@ -28,7 +28,7 @@ fn concat(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Array(v1))
 }
 
-fn reverse(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "array.reverse";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -37,7 +37,7 @@ fn reverse(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Array(v1))
 }
 
-fn slice(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn slice(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "array.slice";
     ensure_args_count(span, name, params, args, 3)?;
 

src/builtins/bitwise.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_numeric};
 
@@ -21,7 +21,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("bits.xor", (xor, 2));
 }
 
-fn and(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn and(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.and";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -38,7 +38,7 @@ fn and(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_float((v1 & v2) as Float))
 }
 
-fn lsh(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn lsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.lsh";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -60,7 +60,7 @@ fn lsh(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_float((v1 << v2) as Float))
 }
 
-fn negate(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn negate(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.negate";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -75,7 +75,7 @@ fn negate(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_float((!v) as Float))
 }
 
-fn or(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn or(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.or";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -92,7 +92,7 @@ fn or(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_float((v1 | v2) as Float))
 }
 
-fn rsh(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn rsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.rsh";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -114,7 +114,7 @@ fn rsh(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_float((v1 >> v2) as Float))
 }
 
-fn xor(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn xor(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "bits.xor";
     ensure_args_count(span, name, params, args, 2)?;
 

src/builtins/conversions.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::ensure_args_count;
 use crate::lexer::Span;
@@ -15,7 +15,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("to_number", (to_number, 1));
 }
 
-fn to_number(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn to_number(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "to_number";
     ensure_args_count(span, name, params, args, 1)?;
 

src/builtins/debugging.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::lexer::Span;
 use crate::value::Value;
@@ -20,7 +20,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
 // Symbol analyzer must ensure that vars used by print are defined before
 // the print statement. Scheduler must ensure the above constraint.
 // Additionally interpreter must allow undefined inputs to print.
-fn print(span: &Span, _params: &[Expr], args: &[Value]) -> Result<Value> {
+fn print(span: &Span, _params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     if args.len() > MAX_ARGS as usize {
         bail!(span.error("print supports up to 100 arguments"));
     }

src/builtins/deprecated.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins::utils::ensure_args_count;
 use crate::builtins::BuiltinFcn;
 use crate::lexer::Span;
@@ -24,7 +24,7 @@ lazy_static! {
     };
 }
 
-fn all(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn all(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "all", params, args, 1)?;
 
     Ok(Value::Bool(match &args[0] {
@@ -37,7 +37,7 @@ fn all(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn any(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn any(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "any", params, args, 1)?;
 
     Ok(Value::Bool(match &args[0] {

src/builtins/encoding.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_string};
 use crate::lexer::Span;
@@ -16,7 +16,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("base64.decode", (base64_decode, 1));
 }
 
-fn base64_decode(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn base64_decode(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "base64.decode";
     ensure_args_count(span, name, params, args, 1)?;
 

src/builtins/mod.rs

@@ -18,7 +18,7 @@ mod tracing;
 pub mod types;
 mod utils;
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::lexer::Span;
 use crate::value::Value;
 
@@ -27,7 +27,7 @@ use std::collections::HashMap;
 use anyhow::Result;
 use lazy_static::lazy_static;
 
-pub type BuiltinFcn = (fn(&Span, &[Expr], &[Value]) -> Result<Value>, u8);
+pub type BuiltinFcn = (fn(&Span, &[Ref<Expr>], &[Value]) -> Result<Value>, u8);
 
 pub use deprecated::DEPRECATED;
 

src/builtins/numbers.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::{ArithOp, Expr};
+use crate::ast::{ArithOp, Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_numeric, ensure_string};
 use crate::lexer::Span;
@@ -45,28 +45,28 @@ pub fn arithmetic_operation(
     }))
 }
 
-fn abs(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn abs(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "abs", params, args, 1)?;
     Ok(Value::from_float(
         ensure_numeric("abs", &params[0], &args[0])?.abs(),
     ))
 }
 
-fn ceil(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn ceil(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "ceil", params, args, 1)?;
     Ok(Value::from_float(
         ensure_numeric("ceil", &params[0], &args[0])?.ceil(),
     ))
 }
 
-fn floor(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn floor(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "floor", params, args, 1)?;
     Ok(Value::from_float(
         ensure_numeric("floor", &params[0], &args[0])?.floor(),
     ))
 }
 
-fn range(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn range(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "numbers.range", params, args, 2)?;
     let v1 = ensure_numeric("numbers.range", &params[0], &args[0].clone())?;
     let v2 = ensure_numeric("numbers.range", &params[1], &args[1].clone())?;
@@ -90,14 +90,14 @@ fn range(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_array(values))
 }
 
-fn round(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn round(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "round", params, args, 1)?;
     Ok(Value::from_float(
         ensure_numeric("round", &params[0], &args[0])?.round(),
     ))
 }
 
-fn intn(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn intn(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let fcn = "rand.intn";
     ensure_args_count(span, fcn, params, args, 2)?;
     let _ = ensure_string(fcn, &params[0], &args[0])?;

src/builtins/objects.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_object};
 use crate::lexer::Span;
@@ -121,7 +121,7 @@ fn merge_filters(
     Ok(filters)
 }
 
-fn json_filter(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn json_filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "json.filter";
     ensure_args_count(span, name, params, args, 2)?;
     ensure_object(name, &params[0], args[0].clone())?;
@@ -135,7 +135,7 @@ fn json_filter(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(json_filter_impl(&args[0], &filters))
 }
 
-fn filter(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "object.filter";
     ensure_args_count(span, name, params, args, 2)?;
     let mut obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -153,7 +153,7 @@ fn filter(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Object(obj))
 }
 
-fn get(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn get(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "object.get";
     ensure_args_count(span, name, params, args, 3)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -178,14 +178,14 @@ fn get(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn keys(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn keys(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "object.keys";
     ensure_args_count(span, name, params, args, 1)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
     Ok(Value::from_set(obj.keys().cloned().collect()))
 }
 
-fn remove(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn remove(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "object.remove";
     ensure_args_count(span, name, params, args, 2)?;
     let mut obj = ensure_object(name, &params[0], args[0].clone())?;

src/builtins/sets.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_set};
 use crate::lexer::Span;
@@ -34,7 +34,7 @@ pub fn difference(expr1: &Expr, expr2: &Expr, v1: Value, v2: Value) -> Result<Va
     Ok(Value::from_set(s1.difference(&s2).cloned().collect()))
 }
 
-fn intersection_of_set_of_sets(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn intersection_of_set_of_sets(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "intersection";
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;
@@ -61,7 +61,7 @@ fn intersection_of_set_of_sets(span: &Span, params: &[Expr], args: &[Value]) ->
     Ok(Value::from_set(res))
 }
 
-fn union_of_set_of_sets(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn union_of_set_of_sets(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "union";
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;

src/builtins/strings.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{
     ensure_args_count, ensure_array, ensure_numeric, ensure_object, ensure_string,
@@ -41,7 +41,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("upper", (upper, 1));
 }
 
-fn concat(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "concat";
     ensure_args_count(span, name, params, args, 2)?;
     let delimiter = ensure_string(name, &params[0], &args[0])?;
@@ -49,7 +49,7 @@ fn concat(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::String(collection.join(&delimiter)))
 }
 
-fn contains(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn contains(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "contains";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -57,7 +57,7 @@ fn contains(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Bool(s1.contains(&s2)))
 }
 
-fn endswith(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn endswith(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "endswith";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -65,7 +65,7 @@ fn endswith(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Bool(s1.ends_with(&s2)))
 }
 
-fn format_int(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn format_int(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "endswith";
     ensure_args_count(span, name, params, args, 2)?;
     let mut n = ensure_numeric(name, &params[0], &args[0])?;
@@ -88,7 +88,7 @@ fn format_int(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn indexof(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn indexof(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "indexof";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -100,7 +100,7 @@ fn indexof(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
 }
 
 #[allow(dead_code)]
-fn indexof_n(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn indexof_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "indexof_n";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -119,14 +119,14 @@ fn indexof_n(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::from_array(positions))
 }
 
-fn lower(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn lower(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "lower";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.to_lowercase()))
 }
 
-fn replace(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn replace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "replace";
     ensure_args_count(span, name, params, args, 3)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -135,7 +135,7 @@ fn replace(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s.replace(&old, &new)))
 }
 
-fn split(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn split(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "replace";
     ensure_args_count(span, name, params, args, 2)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -148,7 +148,7 @@ fn split(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn sprintf(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn sprintf(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "sprintf";
     ensure_args_count(span, name, params, args, 2)?;
     let fmt = ensure_string(name, &params[0], &args[0])?;
@@ -315,7 +315,7 @@ fn sprintf(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s.to_string()))
 }
 
-fn any_prefix_match(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn any_prefix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "strings.any_prefix_match";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -346,7 +346,7 @@ fn any_prefix_match(span: &Span, params: &[Expr], args: &[Value]) -> Result<Valu
     ))
 }
 
-fn any_suffix_match(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn any_suffix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "strings.any_suffix_match";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -377,7 +377,7 @@ fn any_suffix_match(span: &Span, params: &[Expr], args: &[Value]) -> Result<Valu
     ))
 }
 
-fn startswith(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn startswith(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "startswith";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -385,7 +385,7 @@ fn startswith(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::Bool(s1.starts_with(&s2)))
 }
 
-fn replace_n(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn replace_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim";
     ensure_args_count(span, name, params, args, 2)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -408,14 +408,14 @@ fn replace_n(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s))
 }
 
-fn reverse(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "reverse";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.chars().rev().collect()))
 }
 
-fn substring(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn substring(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "substring";
     ensure_args_count(span, name, params, args, 3)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -443,7 +443,7 @@ fn substring(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s[offset..offset + length].to_string()))
 }
 
-fn trim(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -453,7 +453,7 @@ fn trim(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn trim_left(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim_left(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim_left";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -463,7 +463,7 @@ fn trim_left(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn trim_prefix(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim_prefix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim_prefix";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -474,7 +474,7 @@ fn trim_prefix(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn trim_right(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim_right(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim_right";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -484,14 +484,14 @@ fn trim_right(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn trim_space(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim_space(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim_space";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.trim().to_string()))
 }
 
-fn trim_suffix(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trim_suffix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trim_suffix";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -502,7 +502,7 @@ fn trim_suffix(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn upper(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn upper(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "upper";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;

src/builtins/time.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::ensure_args_count;
 use crate::lexer::Span;
@@ -16,7 +16,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("time.now_ns", (now_ns, 0));
 }
 
-fn now_ns(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn now_ns(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "time.now_ns";
     ensure_args_count(span, name, params, args, 0)?;
 

src/builtins/tracing.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_string};
 use crate::lexer::Span;
@@ -17,7 +17,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
 
 // Symbol analyzer must ensure that vars used by trace are defined before
 // the trace statement. Scheduler must ensure the above constraint.
-fn trace(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn trace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     let name = "trace";
     ensure_args_count(span, name, params, args, 1)?;
     let msg = ensure_string(name, &params[0], &args[0])?;

src/builtins/types.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::builtins;
 use crate::builtins::utils::ensure_args_count;
 use crate::lexer::Span;
@@ -22,37 +22,37 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("type_name", (type_name, 1));
 }
 
-fn is_array(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_array(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_array", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Array(_))))
 }
 
-fn is_boolean(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_boolean(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_boolean", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Bool(_))))
 }
 
-fn is_null(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_null(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_null", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Null)))
 }
 
-fn is_number(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_number(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_number", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Number(_))))
 }
 
-fn is_object(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_object(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_object", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Object(_))))
 }
 
-fn is_set(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_set(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_set", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Set(_))))
 }
 
-fn is_string(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+fn is_string(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "is_string", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::String(_))))
 }
@@ -70,7 +70,7 @@ pub fn get_type(value: &Value) -> &str {
     }
 }
 
-pub fn type_name(span: &Span, params: &[Expr], args: &[Value]) -> Result<Value> {
+pub fn type_name(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ensure_args_count(span, "type_name", params, args, 1)?;
     Ok(Value::String(get_type(&args[0]).to_string()))
 }

src/builtins/utils.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ast::Expr;
+use crate::ast::{Expr, Ref};
 use crate::lexer::Span;
 use crate::value::{Float, Value};
 
@@ -13,7 +13,7 @@ use anyhow::{bail, Result};
 pub fn ensure_args_count(
     span: &Span,
     fcn: &'static str,
-    params: &[Expr],
+    params: &[Ref<Expr>],
     args: &[Value],
     expected: usize,
 ) -> Result<()> {