feat(lang): add std.contains function

Author: eduardosm

rsjsonnet-lang/src/program/data.rs

@@ -785,6 +785,7 @@ pub(super) enum BuiltInFunc {
     Avg,
     MinArray,
     MaxArray,
+    Contains,
     // Sets
     Set,
     SetInter,

rsjsonnet-lang/src/program/eval/call.rs

@@ -916,6 +916,12 @@ impl<'p> Evaluator<'_, 'p> {
                 self.state_stack.push(State::DoThunk(arg1.view()));
                 self.state_stack.push(State::DoThunk(arg0.view()));
             }
+            BuiltInFunc::Contains => {
+                let [arg0, arg1] = check_num_args(args);
+                self.state_stack
+                    .push(State::StdContains { value: arg1.view() });
+                self.state_stack.push(State::DoThunk(arg0.view()));
+            }
             BuiltInFunc::Set => {
                 let [arg0, arg1] = check_num_args(args);
                 self.state_stack.push(State::StdSet);

rsjsonnet-lang/src/program/eval/mod.rs

@@ -1470,6 +1470,8 @@ impl<'p, 'a> Evaluator<'a, 'p> {
                     cur_index,
                     max_index,
                 } => self.do_std_max_array_check_item(keyf, array, cur_index, max_index)?,
+                State::StdContains { value } => self.do_std_contains(value)?,
+                State::StdContainsItem { array, index } => self.do_std_contains_item(array, index),
                 State::StdSet => self.do_std_set()?,
                 State::StdSetUniq {
                     orig_array,

rsjsonnet-lang/src/program/eval/state.rs

@@ -437,6 +437,13 @@ pub(super) enum State<'a, 'p> {
         cur_index: usize,
         max_index: usize,
     },
+    StdContains {
+        value: GcView<ThunkData<'p>>,
+    },
+    StdContainsItem {
+        array: GcView<ArrayData<'p>>,
+        index: usize,
+    },
     StdSet,
     StdSetUniq {
         orig_array: GcView<ArrayData<'p>>,

rsjsonnet-lang/src/program/eval/stdlib.rs

@@ -3098,6 +3098,48 @@ impl<'p> Evaluator<'_, 'p> {
         Ok(())
     }
 
+    pub(super) fn do_std_contains(&mut self, value: GcView<ThunkData<'p>>) -> EvalResult<()> {
+        let array = self.value_stack.pop().unwrap();
+        let array = self.expect_std_func_arg_array(array, "contains", 0)?;
+
+        if let Some(item0) = array.first() {
+            let item0 = item0.view();
+
+            self.state_stack
+                .push(State::StdContainsItem { array, index: 0 });
+            self.state_stack.push(State::EqualsValue);
+            self.state_stack.push(State::DoThunk(item0));
+            self.state_stack.push(State::DoThunk(value.clone()));
+            self.state_stack.push(State::DoThunk(value));
+        } else {
+            self.value_stack.push(ValueData::Bool(false));
+        }
+
+        Ok(())
+    }
+
+    pub(super) fn do_std_contains_item(&mut self, array: GcView<ArrayData<'p>>, index: usize) {
+        let equal = self.bool_stack.pop().unwrap();
+        if equal {
+            *self.value_stack.last_mut().unwrap() = ValueData::Bool(true);
+        } else {
+            let next_index = index + 1;
+            if let Some(next_item) = array.get(next_index) {
+                let next_item = next_item.view();
+                self.value_stack
+                    .push(self.value_stack.last().unwrap().clone());
+                self.state_stack.push(State::StdContainsItem {
+                    array,
+                    index: next_index,
+                });
+                self.state_stack.push(State::EqualsValue);
+                self.state_stack.push(State::DoThunk(next_item));
+            } else {
+                *self.value_stack.last_mut().unwrap() = ValueData::Bool(false);
+            }
+        }
+    }
+
     pub(super) fn do_std_set(&mut self) -> EvalResult<()> {
         let keyf = self.value_stack.pop().unwrap();
         let arr = self.value_stack.pop().unwrap();

rsjsonnet-lang/src/program/stdlib.rs

@@ -227,6 +227,7 @@ impl<'p> Program<'p> {
         add_simple("any", BuiltInFunc::Any, &["arr"]);
         add_simple("sum", BuiltInFunc::Sum, &["sum"]);
         add_simple("avg", BuiltInFunc::Avg, &["avg"]);
+        add_simple("contains", BuiltInFunc::Contains, &["arr", "elem"]);
         add_simple("base64", BuiltInFunc::Base64, &["input"]);
         add_simple(
             "base64DecodeBytes",

ui-tests/fail/stdlib/contains/invalid_arg.jsonnet

@@ -0,0 +1 @@
+std.contains(null, 0)

ui-tests/fail/stdlib/contains/invalid_arg.stderr

@@ -0,0 +1,8 @@
+error: first argument of `std.contains` is expected to be array, got null
+note: while evaluating call to `contains`
+ --> invalid_arg.jsonnet:1:1
+  |
+1 | std.contains(null, 0)
+  | ---------------------
+note: during top-level value evaluation
+

ui-tests/pass/stdlib/contains.jsonnet

@@ -0,0 +1,9 @@
+std.assertEqual(std.contains([], "x"), false) &&
+std.assertEqual(std.contains(["x"], "x"), true) &&
+std.assertEqual(std.contains(["x"], "y"), false) &&
+std.assertEqual(std.contains(["a", "b", "c"], "x"), false) &&
+std.assertEqual(std.contains(["a", "b", "c"], "a"), true) &&
+std.assertEqual(std.contains(["a", "b", "c"], "b"), true) &&
+std.assertEqual(std.contains(["a", "b", "c"], "c"), true) &&
+
+true