lint & format

Author: alex-ozdemir

src/ir/opt/chall.rs

@@ -54,7 +54,8 @@ pub fn deskolemize_witnesses(comp: &mut Computation) {
             if let Op::Witness(prefix) = orig.op() {
                 let name = self.0.mk_uniq(prefix);
                 let sort = check(orig);
-                let var = computation.new_var(&name, sort, Some(PROVER_ID), Some(orig.cs()[0].clone()));
+                let var =
+                    computation.new_var(&name, sort, Some(PROVER_ID), Some(orig.cs()[0].clone()));
                 Some(var)
             } else {
                 None

src/ir/opt/mem/obliv.rs

@@ -125,11 +125,9 @@ impl OblivRewriter {
             Op::Witness(s) => {
                 let arg = &t.cs()[0];
                 (
-                    if let Some(targ) = self.tups.get(arg) {
-                        Some(term![Op::Witness(s.clone()); targ.clone()])
-                    } else {
-                        None
-                    },
+                    self.tups
+                        .get(arg)
+                        .map(|targ| term![Op::Witness(s.clone()); targ.clone()]),
                     None,
                 )
             }

src/ir/opt/mem/ram/volatile.rs

@@ -367,6 +367,8 @@ impl RewritePass for Extactor {
                     .collect::<Vec<_>>(),
                 cache.keys().cloned().collect(),
             ) {
+                // false positive: the value constructor uses `cache`.
+                #[allow(clippy::map_entry)]
                 if !cache.contains_key(&t) {
                     let new_t = term(
                         t.op().clone(),
@@ -378,7 +380,11 @@ impl RewritePass for Extactor {
                     cache.insert(t, new_t);
                 }
             }
-            for (name, _sort) in computation.precomputes.sequence()[..initial_precompute_len].to_owned() {
+            // false positive; need to clone to drop reference.
+            #[allow(clippy::unnecessary_to_owned)]
+            for (name, _sort) in
+                computation.precomputes.sequence()[..initial_precompute_len].to_owned()
+            {
                 let term = computation.precomputes.outputs.get_mut(&name).unwrap();
                 *term = cache.get(term).unwrap().clone();
             }

src/ir/opt/mod.rs

@@ -62,7 +62,7 @@ pub enum Opt {
 /// Run optimizations on `cs`, in this order, returning the new constraint system.
 pub fn opt<I: IntoIterator<Item = Opt>>(mut cs: Computations, optimizations: I) -> Computations {
     for c in cs.comps.values() {
-        trace!("Before all opts: {}", text::serialize_computation(&c));
+        trace!("Before all opts: {}", text::serialize_computation(c));
     }
     for i in optimizations {
         debug!("Applying: {:?}", i);
@@ -163,7 +163,7 @@ pub fn opt<I: IntoIterator<Item = Opt>>(mut cs: Computations, optimizations: I)
                 }
             }
             debug!("After {:?}: {} outputs", i, c.outputs.len());
-            trace!("After {:?}: {}", i, text::serialize_computation(&c));
+            trace!("After {:?}: {}", i, text::serialize_computation(c));
             //debug!("After {:?}: {}", i, Letified(cs.outputs[0].clone()));
             debug!("After {:?}: {} terms", i, c.terms());
             #[cfg(debug_assertions)]

src/ir/opt/scalarize_vars.rs

@@ -120,7 +120,7 @@ impl RewritePass for Pass {
             if !sort.is_scalar() {
                 trace!("Considering witness: {}", name);
             }
-            Some(create_wits(&name, cs.pop().unwrap(), &sort))
+            Some(create_wits(name, cs.pop().unwrap(), &sort))
         } else {
             None
         }

src/ir/opt/tuple.rs

@@ -149,6 +149,7 @@ impl TupleTree {
             _ => panic!("{:?} is tuple!", self),
         }
     }
+    #[allow(clippy::wrong_self_convention)]
     fn as_term(self) -> Term {
         match self {
             TupleTree::NonTuple(t) => t,

src/ir/term/ext.rs

@@ -6,8 +6,8 @@ use circ_hc::Node;
 use serde::{Deserialize, Serialize};
 
 mod haboeck;
-mod pf_batch_inv;
 mod map;
+mod pf_batch_inv;
 mod poly;
 mod ram;
 mod sort;

src/ir/term/ext/ram.rs

@@ -9,7 +9,7 @@ pub fn check(arg_sorts: &[&Sort]) -> Result<Sort, TypeErrorReason> {
     let &[entries, indices] = ty::count_or_ref(arg_sorts)?;
     let (size, value) = ty::homogenous_tuple_or(entries, "PersistentRamSplit entries")?;
     let [old, new] = ty::count_or(ty::tuple_or(value, "PersistentRamSplit entries")?)?;
-    eq_or(&old, &new, "PersistentRamSplit entries")?;
+    eq_or(old, new, "PersistentRamSplit entries")?;
     let (i_size, i_value) = ty::homogenous_tuple_or(indices, "PersistentRamSplit indices")?;
     let f = pf_or(i_value, "PersistentRamSplit indices")?;
     let n_touched = i_size.min(size);

src/ir/term/extras.rs

@@ -277,7 +277,7 @@ pub fn node_cs_iter(node: Term) -> impl Iterator<Item = Term> {
 //     /// Any extra dependencies that should be traversed before this term.
 //     fn extra_dependencies(&mut self, t: &Term) -> Option<Vec<Term>> { None }
 // }
-// 
+//
 // pub struct TermTraversal {
-//     
+//
 // }

src/ir/term/ty.rs

@@ -687,7 +687,7 @@ pub(super) fn homogenous_tuple_or<'a>(
     ctx: &'static str,
 ) -> Result<(usize, &'a Sort), TypeErrorReason> {
     let sorts = tuple_or(a, ctx)?;
-    if sorts.len() > 0 {
+    if !sorts.is_empty() {
         for i in 1..sorts.len() {
             if sorts[0] != sorts[i] {
                 return Err(TypeErrorReason::ExpectedHomogenousTuple(ctx));