Fix some warnings

src/circuit_builder.rs

@@ -202,14 +202,14 @@ impl<F: Field> CircuitBuilder<F> {
     /// Builds a "prover circuit", with data needed to generate proofs but not verify them.
     pub fn build_prover(mut self) -> ProverCircuitData<F> {
         // TODO: Can skip parts of this.
-        let CircuitData { prover_only, verifier_only, common } = self.build();
+        let CircuitData { prover_only, common, .. } = self.build();
         ProverCircuitData { prover_only, common }
     }
 
     /// Builds a "verifier circuit", with data needed to verify proofs but not generate them.
     pub fn build_verifier(mut self) -> VerifierCircuitData<F> {
         // TODO: Can skip parts of this.
-        let CircuitData { prover_only, verifier_only, common } = self.build();
+        let CircuitData { verifier_only, common, .. } = self.build();
         VerifierCircuitData { verifier_only, common }
     }
 }

src/constraint_polynomial.rs

@@ -1,17 +1,5 @@
-use std::{fmt, ptr};
-use std::borrow::Borrow;
-use std::collections::{HashMap, HashSet};
-use std::fmt::{Debug, Display, Formatter};
-use std::hash::{Hash, Hasher};
-use std::iter::{Product, Sum};
-use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-use std::rc::Rc;
-
-use num::{BigUint, FromPrimitive, One, Zero};
-
 use crate::field::field::Field;
 use crate::target::Target;
-use crate::wire::Wire;
 
 #[derive(Copy, Clone)]
 pub struct EvaluationVars<'a, F: Field> {

src/field/crandall_field.rs

@@ -1,10 +1,11 @@
-use std::fmt::{Debug, Formatter, Display};
+use std::fmt::{Debug, Display, Formatter};
 use std::fmt;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
-use crate::field::field::Field;
 use num::Integer;
 
+use crate::field::field::Field;
+
 /// P = 2**64 - EPSILON
 ///   = 2**64 - 9 * 2**28 + 1
 ///   = 2**28 * (2**36 - 9) + 1

src/field/fft.rs

@@ -1,6 +1,6 @@
 use crate::field::field::Field;
+use crate::polynomial::polynomial::{PolynomialCoeffs, PolynomialValues};
 use crate::util::{log2_ceil, log2_strict};
-use crate::polynomial::polynomial::{PolynomialValues, PolynomialCoeffs};
 
 /// Permutes `arr` such that each index is mapped to its reverse in binary.
 fn reverse_index_bits<T: Copy>(arr: Vec<T>) -> Vec<T> {

src/gadgets/split_join.rs

@@ -1,10 +1,8 @@
-use std::iter;
-
 use crate::field::field::Field;
 use crate::generator::{SimpleGenerator, WitnessGenerator};
 use crate::target::Target;
-use crate::witness::PartialWitness;
 use crate::wire::Wire;
+use crate::witness::PartialWitness;
 
 // /// Constraints for a little-endian split.
 // pub fn split_le_constraints<F: Field>(

src/gates/constant.rs

@@ -4,8 +4,8 @@ use crate::field::field::Field;
 use crate::gates::gate::{Gate, GateRef};
 use crate::generator::{SimpleGenerator, WitnessGenerator};
 use crate::target::Target;
-use crate::witness::PartialWitness;
 use crate::wire::Wire;
+use crate::witness::PartialWitness;
 
 /// A gate which takes a single constant parameter and outputs that value.
 pub struct ConstantGate;
@@ -45,7 +45,7 @@ impl<F: Field> Gate<F> for ConstantGate {
         &self,
         gate_index: usize,
         local_constants: &[F],
-        next_constants: &[F],
+        _next_constants: &[F],
     ) -> Vec<Box<dyn WitnessGenerator<F>>> {
         let gen = ConstantGenerator {
             gate_index,
@@ -82,7 +82,7 @@ impl<F: Field> SimpleGenerator<F> for ConstantGenerator<F> {
         Vec::new()
     }
 
-    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F> {
+    fn run_once(&self, _witness: &PartialWitness<F>) -> PartialWitness<F> {
         let wire = Wire { gate: self.gate_index, input: ConstantGate::WIRE_OUTPUT };
         PartialWitness::singleton(Target::Wire(wire), self.constant)
     }

src/gates/gate.rs

@@ -1,8 +1,6 @@
 use std::hash::{Hash, Hasher};
 use std::rc::Rc;
 
-use num::ToPrimitive;
-
 use crate::circuit_builder::CircuitBuilder;
 use crate::constraint_polynomial::{EvaluationTargets, EvaluationVars};
 use crate::field::field::Field;

src/gates/gmimc.rs

@@ -1,17 +1,13 @@
 use std::sync::Arc;
 
-use num::{BigUint, One};
-
 use crate::circuit_builder::CircuitBuilder;
-use crate::circuit_data::CircuitConfig;
 use crate::constraint_polynomial::{EvaluationTargets, EvaluationVars};
 use crate::field::field::Field;
 use crate::gates::gate::{Gate, GateRef};
 use crate::generator::{SimpleGenerator, WitnessGenerator};
 use crate::target::Target;
-use crate::witness::PartialWitness;
 use crate::wire::Wire;
-use crate::gates::noop::NoopGate;
+use crate::witness::PartialWitness;
 
 /// The width of the permutation, in field elements.
 const W: usize = 12;

src/gates/noop.rs

@@ -1,10 +1,9 @@
-use crate::circuit_data::CircuitConfig;
-use crate::constraint_polynomial::{EvaluationVars, EvaluationTargets};
+use crate::circuit_builder::CircuitBuilder;
+use crate::constraint_polynomial::{EvaluationTargets, EvaluationVars};
 use crate::field::field::Field;
 use crate::gates::gate::{Gate, GateRef};
 use crate::generator::WitnessGenerator;
 use crate::target::Target;
-use crate::circuit_builder::CircuitBuilder;
 
 /// A gate which takes a single constant parameter and outputs that value.
 pub struct NoopGate;
@@ -20,23 +19,23 @@ impl<F: Field> Gate<F> for NoopGate {
         "NoopGate".into()
     }
 
-    fn eval_unfiltered(&self, vars: EvaluationVars<F>) -> Vec<F> {
+    fn eval_unfiltered(&self, _vars: EvaluationVars<F>) -> Vec<F> {
         Vec::new()
     }
 
     fn eval_unfiltered_recursively(
         &self,
         _builder: &mut CircuitBuilder<F>,
-        vars: EvaluationTargets,
+        _vars: EvaluationTargets,
     ) -> Vec<Target> {
         Vec::new()
     }
 
     fn generators(
         &self,
-        gate_index: usize,
-        local_constants: &[F],
-        next_constants: &[F],
+        _gate_index: usize,
+        _local_constants: &[F],
+        _next_constants: &[F],
     ) -> Vec<Box<dyn WitnessGenerator<F>>> {
         Vec::new()
     }

src/gmimc.rs

@@ -80,10 +80,11 @@ pub fn gmimc_permute_naive<F: Field, const W: usize, const R: usize>(
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
     use crate::field::crandall_field::CrandallField;
     use crate::field::field::Field;
     use crate::gmimc::{gmimc_permute, gmimc_permute_naive};
-    use std::sync::Arc;
 
     #[test]
     fn consistency() {

src/hash.rs

@@ -2,13 +2,12 @@
 
 use std::convert::TryInto;
 
-use num::traits::real::Real;
 use rayon::prelude::*;
 
 use crate::field::field::Field;
-use crate::gmimc::{gmimc_compress, gmimc_permute_array};
+use crate::gmimc::gmimc_permute_array;
 use crate::proof::Hash;
-use crate::util::{reverse_index_bits, reverse_index_bits_in_place, transpose};
+use crate::util::reverse_index_bits_in_place;
 
 const RATE: usize = 8;
 const CAPACITY: usize = 4;

src/plonk_common.rs

@@ -1,6 +1,6 @@
+use crate::circuit_builder::CircuitBuilder;
 use crate::field::field::Field;
 use crate::target::Target;
-use crate::circuit_builder::CircuitBuilder;
 
 pub(crate) fn reduce_with_powers<F: Field>(terms: Vec<F>, alpha: F) -> F {
     let mut sum = F::ZERO;

src/polynomial/division.rs

@@ -1,7 +1,7 @@
 use crate::field::fft::{fft, ifft};
 use crate::field::field::Field;
-use crate::util::{log2_ceil, log2_strict};
 use crate::polynomial::polynomial::PolynomialCoeffs;
+use crate::util::log2_strict;
 
 /// Takes a polynomial `a` in coefficient form, and divides it by `Z_H = X^n - 1`.
 ///

src/polynomial/polynomial.rs

@@ -1,6 +1,6 @@
+use crate::field::fft::{fft, ifft};
 use crate::field::field::Field;
 use crate::util::log2_strict;
-use crate::field::fft::{ifft, fft};
 
 /// A polynomial in point-value form. The number of values must be a power of two.
 ///

src/prover.rs

@@ -8,14 +8,14 @@ use crate::constraint_polynomial::EvaluationVars;
 use crate::field::fft::{fft, ifft};
 use crate::field::field::Field;
 use crate::generator::generate_partial_witness;
-use crate::hash::{merkle_root_bit_rev_order};
+use crate::hash::merkle_root_bit_rev_order;
 use crate::plonk_common::reduce_with_powers;
-use crate::proof::{Proof};
-use crate::util::{transpose, transpose_poly_values};
+use crate::polynomial::division::divide_by_z_h;
+use crate::polynomial::polynomial::{PolynomialCoeffs, PolynomialValues};
+use crate::proof::Proof;
+use crate::util::transpose_poly_values;
 use crate::wire::Wire;
 use crate::witness::PartialWitness;
-use crate::polynomial::division::divide_by_z_h;
-use crate::polynomial::polynomial::{PolynomialValues, PolynomialCoeffs};
 
 pub(crate) fn prove<F: Field>(
     prover_data: &ProverOnlyCircuitData<F>,

src/util.rs

@@ -1,5 +1,5 @@
-use crate::polynomial::polynomial::PolynomialValues;
 use crate::field::field::Field;
+use crate::polynomial::polynomial::PolynomialValues;
 
 pub(crate) fn ceil_div_usize(a: usize, b: usize) -> usize {
     (a + b - 1) / b