Implements boolean logical and/or in kcl (#4678)

* redoing bool logic impl on latest main

* adding snapshot tests (removing .new)

* removing accidental change smh:(

* accepting client side scene snapshot

* accepting png snapshot and triggering ci

* A snapshot a day keeps the bugs away! 📷🐛 (OS: ubuntu-latest-8-cores)

* accepting png again?

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest-8-cores)

* accepting grid visibility snapshot

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest-8-cores)

* accepting png snapshot

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest-8-cores)

* accepting png snapshot

* A snapshot a day keeps the bugs away! 📷🐛 (OS: ubuntu-latest-8-cores)

* accepting png snapshot

* rerunning simtest creation to get ops.snap files

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Jonathan Tran <jonnytran@gmail.com>

src/wasm-lib/kcl/src/execution/exec_ast.rs

@@ -170,6 +170,42 @@ impl Node<BinaryExpression> {
             }
         }
 
+        // Check if we are doing logical operations on booleans.
+        if self.operator == BinaryOperator::Or || self.operator == BinaryOperator::And {
+            let KclValue::Bool {
+                value: left_value,
+                meta: _,
+            } = left_value
+            else {
+                return Err(KclError::Semantic(KclErrorDetails {
+                    message: format!(
+                        "Cannot apply logical operator to non-boolean value: {}",
+                        left_value.human_friendly_type()
+                    ),
+                    source_ranges: vec![self.left.clone().into()],
+                }));
+            };
+            let KclValue::Bool {
+                value: right_value,
+                meta: _,
+            } = right_value
+            else {
+                return Err(KclError::Semantic(KclErrorDetails {
+                    message: format!(
+                        "Cannot apply logical operator to non-boolean value: {}",
+                        right_value.human_friendly_type()
+                    ),
+                    source_ranges: vec![self.right.clone().into()],
+                }));
+            };
+            let raw_value = match self.operator {
+                BinaryOperator::Or => left_value || right_value,
+                BinaryOperator::And => left_value && right_value,
+                _ => unreachable!(),
+            };
+            return Ok(KclValue::Bool { value: raw_value, meta });
+        }
+
         let left = parse_number_as_f64(&left_value, self.left.clone().into())?;
         let right = parse_number_as_f64(&right_value, self.right.clone().into())?;
 
@@ -222,6 +258,7 @@ impl Node<BinaryExpression> {
                 value: left == right,
                 meta,
             },
+            BinaryOperator::And | BinaryOperator::Or => unreachable!(),
         };
 
         Ok(value)