From b00d635820ec67662c7ff87985c9e7cb6cb9ecb5 Mon Sep 17 00:00:00 2001
From: Nick Krichevsky <nick@ollien.com>
Date: Thu, 23 May 2024 12:29:56 -0400
Subject: [PATCH] Handle logical comparisons

---
 src/eval.rs  | 12 ++++++++++++
 src/parse.rs | 10 +++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/eval.rs b/src/eval.rs
index 0ebfcb2..52fabae 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -105,9 +105,21 @@ impl ExprVisitor<Result<EvaluatedValue, ScriptError>> for InterpreterRunner<'_>
         right: &Expr,
     ) -> Result<EvaluatedValue, ScriptError> {
         let left_operand = self.visit_expr(left)?;
+        // These operators must be handled first to allow for short circuiting
+        match operator.kind() {
+            TokenKind::Or if left_operand.is_truthy() => return Ok(left_operand),
+            TokenKind::And if !left_operand.is_truthy() => return Ok(left_operand),
+            _ => {
+                // fall through, evaluate right operand before continuing
+            }
+        }
+
         let right_operand = self.visit_expr(right)?;
 
         match operator.kind() {
+            // Finish the short circuit; if we get to this point the result will always be right.
+            TokenKind::Or | TokenKind::And => Ok(right_operand),
+
             TokenKind::Plus => evaluate_addition((left_operand, right_operand), operator),
 
             TokenKind::Minus => evaluate_binary_arithmetic(
diff --git a/src/parse.rs b/src/parse.rs
index e5e3c56..63c3436 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -272,7 +272,7 @@ fn parse_expression<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result
 }
 
 fn parse_assignment<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result<Expr, ParseError> {
-    let expr = parse_equality(iter)?;
+    let expr = parse_or(iter)?;
     match (match_token_kind!(iter, TokenKind::Equal), expr) {
         (Err(_), expr) => Ok(expr),
 
@@ -292,6 +292,14 @@ fn parse_assignment<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result
     }
 }
 
+fn parse_or<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result<Expr, ParseError> {
+    parse_binary(iter, &[TokenKind::Or], parse_and)
+}
+
+fn parse_and<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result<Expr, ParseError> {
+    parse_binary(iter, &[TokenKind::And], parse_equality)
+}
+
 fn parse_equality<I: Iterator<Item = Token>>(iter: &mut Peekable<I>) -> Result<Expr, ParseError> {
     parse_binary(
         iter,