feat: Implement Short-Circuit Evaluation for AND Expressions to Fix Issue #117 (#118)

* feat: Implement short-circuit evaluation for AND expression

* format code for objects.rs

* format objects.rs code

* fix and Expression

* fix code linter issue

---------

Co-authored-by: raftzhang <[email protected]>

Author: Masterlvng

interpreter/src/context.rs

@@ -40,7 +40,7 @@ pub enum Context<'a> {
     },
 }
 
-impl<'a> Context<'a> {
+impl Context<'_> {
     pub fn add_variable<S, V>(
         &mut self,
         name: S,
@@ -159,7 +159,7 @@ impl<'a> Context<'a> {
     }
 }
 
-impl<'a> Default for Context<'a> {
+impl Default for Context<'_> {
     fn default() -> Self {
         let mut ctx = Context::Root {
             variables: Default::default(),

interpreter/src/functions.rs

@@ -381,7 +381,7 @@ pub fn all(
     ident: Identifier,
     expr: Expression,
 ) -> Result<bool> {
-    return match this {
+    match this {
         Value::List(items) => {
             let mut ptx = ftx.ptx.new_inner_scope();
             for item in items.iter() {
@@ -402,8 +402,8 @@ pub fn all(
             }
             Ok(true)
         }
-        _ => return Err(this.error_expected_type(ValueType::List)),
-    };
+        _ => Err(this.error_expected_type(ValueType::List)),
+    }
 }
 
 /// Returns a boolean value indicating whether a or more values in the provided

interpreter/src/magic.rs

@@ -230,7 +230,7 @@ impl From<Identifier> for String {
 #[derive(Clone)]
 pub struct Arguments(pub Arc<Vec<Value>>);
 
-impl<'a, 'context> FromContext<'a, 'context> for Arguments {
+impl<'a> FromContext<'a, '_> for Arguments {
     fn from_context(ctx: &'a mut FunctionContext) -> Result<Self, ExecutionError>
     where
         Self: Sized,
@@ -389,7 +389,7 @@ impl<'a, 'context, H, T> HandlerCallable<'a, 'context, H, T> {
     }
 }
 
-impl<'a, 'context, H, T> Callable for HandlerCallable<'a, 'context, H, T>
+impl<H, T> Callable for HandlerCallable<'_, '_, H, T>
 where
     H: Handler<T> + Clone + 'static,
 {

interpreter/src/objects.rs

@@ -405,7 +405,7 @@ impl From<Value> for ResolveResult {
     }
 }
 
-impl<'a> Value {
+impl Value {
     pub fn resolve_all(expr: &[Expression], ctx: &Context) -> ResolveResult {
         let mut res = Vec::with_capacity(expr.len());
         for expr in expr {
@@ -415,7 +415,7 @@ impl<'a> Value {
     }
 
     #[inline(always)]
-    pub fn resolve(expr: &'a Expression, ctx: &Context) -> ResolveResult {
+    pub fn resolve(expr: &Expression, ctx: &Context) -> ResolveResult {
         match expr {
             Expression::Atom(atom) => Ok(atom.into()),
             Expression::Arithmetic(left, op, right) => {
@@ -486,8 +486,12 @@ impl<'a> Value {
             }
             Expression::And(left, right) => {
                 let left = Value::resolve(left, ctx)?;
-                let right = Value::resolve(right, ctx)?;
-                Value::Bool(left.to_bool() && right.to_bool()).into()
+                if !left.to_bool() {
+                    Value::Bool(false).into()
+                } else {
+                    let right = Value::resolve(right, ctx)?;
+                    Value::Bool(right.to_bool()).into()
+                }
             }
             Expression::Unary(op, expr) => {
                 let expr = Value::resolve(expr, ctx)?;
@@ -973,4 +977,18 @@ mod tests {
             )))]))
         );
     }
+
+    #[test]
+    fn test_short_curcuit_and() {
+        let mut context = Context::default();
+        let data: HashMap<String, String> = HashMap::new();
+        context.add_variable_from_value("data", data);
+
+        let program = Program::compile("has(data.x) && data.x.startsWith(\"foo\")").unwrap();
+        let value = program.execute(&context);
+        assert!(
+            value.is_ok(),
+            "The AND expression should support short-circuit evaluation."
+        );
+    }
 }

parser/src/ast.rs

@@ -73,7 +73,7 @@ pub struct ExpressionReferences<'expr> {
     functions: HashSet<&'expr str>,
 }
 
-impl<'expr> ExpressionReferences<'expr> {
+impl ExpressionReferences<'_> {
     /// Returns true if the expression references the provided variable name.
     ///
     /// # Example