Move leaf_true, is_leaf_true, and leaf_true_test into StatementTree

sigma_compiler_core/src/sigma/combiners.rs

@@ -6,7 +6,7 @@ use quote::quote;
 use std::collections::HashMap;
 use syn::parse::Result;
 use syn::visit::Visit;
-use syn::Expr;
+use syn::{parse_quote, Expr};
 
 /// For each [`Ident`](struct@syn::Ident) representing a private
 /// `Scalar` (as listed in a [`VarDict`]) that appears in an [`Expr`],
@@ -407,6 +407,21 @@ impl StatementTree {
         }
     }
 
+    /// Produce a [`StatementTree`] that represents the constant `true`
+    pub fn leaf_true() -> StatementTree {
+        StatementTree::Leaf(parse_quote! { true })
+    }
+
+    /// Test if the given [`StatementTree`] represents the constant `true`
+    pub fn is_leaf_true(&self) -> bool {
+        if let StatementTree::Leaf(Expr::Lit(exprlit)) = self {
+            if let syn::Lit::Bool(syn::LitBool { value: true, .. }) = exprlit.lit {
+                return true;
+            }
+        }
+        false
+    }
+
     fn dump_int(&self, depth: usize) {
         match self {
             StatementTree::Leaf(e) => {
@@ -445,7 +460,18 @@ mod test {
     use super::StatementTree::*;
     use super::*;
     use quote::quote;
-    use syn::parse_quote;
+
+    #[test]
+    fn leaf_true_test() {
+        assert!(StatementTree::leaf_true().is_leaf_true());
+        assert!(!StatementTree::Leaf(parse_quote! { false }).is_leaf_true());
+        assert!(!StatementTree::Leaf(parse_quote! { 1 }).is_leaf_true());
+        assert!(!StatementTree::parse(&parse_quote! {
+            OR(1=1, a=b)
+        })
+        .unwrap()
+        .is_leaf_true());
+    }
 
     #[test]
     fn combiners_simple_test() {

sigma_compiler_core/src/transform.rs

@@ -6,21 +6,6 @@
 use super::sigma::combiners::*;
 use syn::{parse_quote, Expr};
 
-/// Produce a [`StatementTree`] that represents the constant `true`
-fn leaf_true() -> StatementTree {
-    StatementTree::Leaf(parse_quote! { true })
-}
-
-/// Test if the given [`StatementTree`] represents the constant `true`
-fn is_leaf_true(st: &StatementTree) -> bool {
-    if let StatementTree::Leaf(Expr::Lit(exprlit)) = st {
-        if let syn::Lit::Bool(syn::LitBool { value: true, .. }) = exprlit.lit {
-            return true;
-        }
-    }
-    false
-}
-
 /// Simplify a [`StatementTree`] by pruning leaves that are the constant
 /// `true`, and simplifying `And`, `Or`, and `Thresh` combiners that
 /// have fewer than two children.
@@ -39,7 +24,7 @@ pub fn prune_statement_tree(st: &mut StatementTree) {
             // Note that v.len _can change_ during this loop
             while i < v.len() {
                 prune_statement_tree(&mut v[i]);
-                if is_leaf_true(&v[i]) {
+                if v[i].is_leaf_true() {
                     // Remove this child, and _do not_ increment i
                     v.remove(i);
                 } else {
@@ -47,7 +32,7 @@ pub fn prune_statement_tree(st: &mut StatementTree) {
                 }
             }
             if v.is_empty() {
-                *st = leaf_true();
+                *st = StatementTree::leaf_true();
             } else if v.len() == 1 {
                 let child = v.remove(0);
                 *st = child;
@@ -63,8 +48,8 @@ pub fn prune_statement_tree(st: &mut StatementTree) {
             // Note that v.len _can change_ during this loop
             while i < v.len() {
                 prune_statement_tree(&mut v[i]);
-                if is_leaf_true(&v[i]) {
-                    *st = leaf_true();
+                if v[i].is_leaf_true() {
+                    *st = StatementTree::leaf_true();
                     return;
                 } else {
                     i += 1;
@@ -86,13 +71,13 @@ pub fn prune_statement_tree(st: &mut StatementTree) {
             // Note that v.len _can change_ during this loop
             while i < v.len() {
                 prune_statement_tree(&mut v[i]);
-                if is_leaf_true(&v[i]) {
+                if v[i].is_leaf_true() {
                     // Remove this child, and _do not_ increment i
                     v.remove(i);
                     // But decrement thresh
                     *thresh -= 1;
                     if *thresh == 0 {
-                        *st = leaf_true();
+                        *st = StatementTree::leaf_true();
                         return;
                     }
                 } else {
@@ -128,19 +113,6 @@ pub fn paren_if_needed(expr: Expr) -> Expr {
 mod tests {
     use super::*;
 
-    #[test]
-    fn leaf_true_test() {
-        assert!(is_leaf_true(&leaf_true()));
-        assert!(!is_leaf_true(&StatementTree::Leaf(parse_quote! { false })));
-        assert!(!is_leaf_true(&StatementTree::Leaf(parse_quote! { 1 })));
-        assert!(!is_leaf_true(
-            &StatementTree::parse(&parse_quote! {
-                OR(1=1, a=b)
-            })
-            .unwrap()
-        ));
-    }
-
     fn prune_tester(e: Expr, pruned_e: Expr) {
         let mut st = StatementTree::parse(&e).unwrap();
         prune_statement_tree(&mut st);