Removed mock feature flag and added mock_build

plonky2/Cargo.toml

@@ -16,7 +16,6 @@ gate_testing = []
 parallel = ["hashbrown/rayon", "plonky2_maybe_rayon/parallel"]
 std = ["anyhow/std", "rand/std", "itertools/use_std"]
 timing = ["std"]
-mock = []
 
 [dependencies]
 ahash = { version = "0.8.3", default-features = false, features = ["compile-time-rng"] } # NOTE: Be sure to keep this version the same as the dependency in `hashbrown`.

plonky2/src/lookup_test.rs

@@ -469,12 +469,10 @@ mod tests {
         Ok(())
     }
 
-    #[cfg(feature = "mock")]
     #[test]
     fn test_circuit_build_mock() {
         // This code is taken from examples/fibonacci.rs
         use crate::field::types::Field;
-        use crate::iop::generator::generate_partial_witness;
         use crate::iop::witness::{PartialWitness, Witness, WitnessWrite};
         use crate::plonk::circuit_builder::CircuitBuilder;
         use crate::plonk::circuit_data::CircuitConfig;
@@ -508,8 +506,8 @@ mod tests {
         pw.set_target(initial_a, F::ZERO);
         pw.set_target(initial_b, F::ONE);
 
-        let data = builder.build::<C>();
-        let partition_witness = generate_partial_witness(pw, &data.prover_only, &data.common);
+        let data = builder.mock_build::<C>();
+        let partition_witness = data.generate_witness(pw);
         let result = partition_witness.try_get_target(cur_target).unwrap();
         assert_eq!(result, F::from_canonical_u64(3736710860384812976));
     }

plonky2/src/plonk/circuit_builder.rs

@@ -40,8 +40,8 @@ use crate::iop::generator::{
 use crate::iop::target::{BoolTarget, Target};
 use crate::iop::wire::Wire;
 use crate::plonk::circuit_data::{
-    CircuitConfig, CircuitData, CommonCircuitData, ProverCircuitData, ProverOnlyCircuitData,
-    VerifierCircuitData, VerifierCircuitTarget, VerifierOnlyCircuitData,
+    CircuitConfig, CircuitData, CommonCircuitData, MockCircuitData, ProverCircuitData,
+    ProverOnlyCircuitData, VerifierCircuitData, VerifierCircuitTarget, VerifierOnlyCircuitData,
 };
 use crate::plonk::config::{AlgebraicHasher, GenericConfig, GenericHashOut, Hasher};
 use crate::plonk::copy_constraint::CopyConstraint;
@@ -916,7 +916,10 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
     }
 
     /// Builds a "full circuit", with both prover and verifier data.
-    pub fn build<C: GenericConfig<D, F = F>>(mut self) -> CircuitData<F, C, D> {
+    pub fn build_with_options<C: GenericConfig<D, F = F>>(
+        mut self,
+        commit_to_sigma: bool,
+    ) -> CircuitData<F, C, D> {
         let mut timing = TimingTree::new("preprocess", Level::Trace);
 
         #[cfg(feature = "std")]
@@ -1024,8 +1027,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         let fft_root_table = fft_root_table(max_fft_points);
 
         let mut constants_sigmas_commitment = PolynomialBatch::<F, C, D>::default();
-        #[cfg(not(feature = "mock"))]
-        {
+        if commit_to_sigma {
             let constants_sigmas_vecs = [constant_vecs, sigma_vecs.clone()].concat();
             constants_sigmas_commitment = PolynomialBatch::<F, C, D>::from_values(
                 constants_sigmas_vecs,
@@ -1155,6 +1157,17 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         }
     }
 
+    pub fn build<C: GenericConfig<D, F = F>>(self) -> CircuitData<F, C, D> {
+        self.build_with_options(true)
+    }
+
+    pub fn mock_build<C: GenericConfig<D, F = F>>(self) -> MockCircuitData<F, C, D> {
+        let circuit_data = self.build_with_options(false);
+        MockCircuitData {
+            prover_only: circuit_data.prover_only,
+            common: circuit_data.common,
+        }
+    }
     /// Builds a "prover circuit", with data needed to generate proofs but not verify them.
     pub fn build_prover<C: GenericConfig<D, F = F>>(self) -> ProverCircuitData<F, C, D> {
         // TODO: Can skip parts of this.

plonky2/src/plonk/circuit_data.rs

@@ -24,9 +24,9 @@ use crate::gates::selectors::SelectorsInfo;
 use crate::hash::hash_types::{HashOutTarget, MerkleCapTarget, RichField};
 use crate::hash::merkle_tree::MerkleCap;
 use crate::iop::ext_target::ExtensionTarget;
-use crate::iop::generator::WitnessGeneratorRef;
+use crate::iop::generator::{generate_partial_witness, WitnessGeneratorRef};
 use crate::iop::target::Target;
-use crate::iop::witness::PartialWitness;
+use crate::iop::witness::{PartialWitness, PartitionWitness};
 use crate::plonk::circuit_builder::CircuitBuilder;
 use crate::plonk::config::{GenericConfig, Hasher};
 use crate::plonk::plonk_common::PlonkOracle;
@@ -111,6 +111,22 @@ impl CircuitConfig {
     }
 }
 
+/// Circuit data required by the prover or the verifier.
+#[derive(Eq, PartialEq, Debug)]
+pub struct MockCircuitData<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
+{
+    pub prover_only: ProverOnlyCircuitData<F, C, D>,
+    pub common: CommonCircuitData<F, D>,
+}
+
+impl<'a, F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
+    MockCircuitData<F, C, D>
+{
+    pub fn generate_witness(&self, inputs: PartialWitness<F>) -> PartitionWitness<F> {
+        generate_partial_witness::<F, C, D>(inputs, &self.prover_only, &self.common)
+    }
+}
+
 /// Circuit data required by the prover or the verifier.
 #[derive(Eq, PartialEq, Debug)]
 pub struct CircuitData<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {