Address review comments

Author: Mohammad Fawaz

compiler/passes/src/destructuring/ast.rs

@@ -69,13 +69,13 @@ impl AstReconstructor for DestructuringVisitor<'_> {
                 .collect();
 
             // Fold appropriately
-            let combined = match input.op {
-                Eq => self.fold_with_and(pieces),
-                Neq => self.fold_with_or(pieces),
+            let op = match input.op {
+                Eq => BinaryOperation::And,
+                Neq => BinaryOperation::Or,
                 _ => unreachable!(),
             };
 
-            return (combined, statements);
+            return (self.fold_with_op(op, pieces.into_iter()), statements);
         }
 
         // Fallback

compiler/passes/src/destructuring/visitor.rs

@@ -106,15 +106,21 @@ impl DestructuringVisitor<'_> {
         }
     }
 
-    /// Folds a list of boolean expressions into a left-associated chain of
-    /// `&&` operations (e.g. `[a, b, c]` → `(a && b) && c`).  
-    /// Panics if the list is empty. Inserts boolean types for all generated nodes.
-    pub fn fold_with_and(&mut self, pieces: Vec<Expression>) -> Expression {
+    /// Folds an iterator of expressions into a left-associated chain using `op`.
+    ///
+    /// Given expressions `[e1, e2, e3]`, this produces `((e1 op e2) op e3)`.
+    /// Each intermediate node is assigned a fresh ID and recorded as `Boolean`
+    /// in the type table.
+    ///
+    /// Panics if the iterator is empty.
+    pub fn fold_with_op<I>(&mut self, op: BinaryOperation, pieces: I) -> Expression
+    where
+        I: Iterator<Item = Expression>,
+    {
         pieces
-            .into_iter()
             .reduce(|left, right| {
                 let expr: Expression = BinaryExpression {
-                    op: BinaryOperation::And,
+                    op,
                     left,
                     right,
                     span: Default::default(),
@@ -125,29 +131,7 @@ impl DestructuringVisitor<'_> {
                 self.state.type_table.insert(expr.id(), Type::Boolean);
                 expr
             })
-            .expect("fold_with_and called with empty vec")
-    }
-
-    /// Folds a list of boolean expressions into a left-associated chain of
-    /// `||` operations (e.g. `[a, b, c]` → `(a || b) || c`).  
-    /// Panics if the list is empty. Inserts boolean types for all generated nodes.
-    pub fn fold_with_or(&mut self, pieces: Vec<Expression>) -> Expression {
-        pieces
-            .into_iter()
-            .reduce(|left, right| {
-                let expr: Expression = BinaryExpression {
-                    op: BinaryOperation::Or,
-                    left,
-                    right,
-                    span: Default::default(),
-                    id: self.state.node_builder.next_id(),
-                }
-                .into();
-
-                self.state.type_table.insert(expr.id(), Type::Boolean);
-                expr
-            })
-            .expect("fold_with_or called with empty vec")
+            .expect("fold_with_op called with empty iterator")
     }
 
     // Given the `expression` of tuple type, make a definition assigning variable to its members.

compiler/passes/src/option_lowering/ast.rs

@@ -173,7 +173,7 @@ impl leo_ast::AstReconstructor for OptionLoweringVisitor<'_> {
                     span: Span::default(),
                     id: self.state.node_builder.next_id(),
                 };
-                self.state.type_table.insert(dbg!(is_some_access.id()), Type::Boolean);
+                self.state.type_table.insert(is_some_access.id(), Type::Boolean);
 
                 // Create assertion: ensure `is_some` is `true`.
                 let assert_stmt = AssertStatement {