chore(fmt): wrap comments and format code comments (#1575)

Author: jonathanpwang

benchmarks/prove/src/bin/verify_fibair.rs

@@ -35,7 +35,8 @@ fn main() -> Result<()> {
     );
 
     run_with_metric_collection("OUTPUT_PATH", || -> Result<()> {
-        // run_test tries to setup tracing, but it will be ignored since run_with_metric_collection already sets it.
+        // run_test tries to setup tracing, but it will be ignored since run_with_metric_collection
+        // already sets it.
         let (fib_air, fib_input) = collect_airs_and_inputs!(fib_chip);
         let vdata = engine.run_test(fib_air, fib_input).unwrap();
         // Unlike other apps, this "app" does not have continuations enabled.

benchmarks/prove/src/util.rs

@@ -208,7 +208,8 @@ where
     });
     // 3. Executes runtime
     // 4. Generate trace
-    // 5. Generate STARK proofs for each segment (segmentation is determined by `config`), with timer.
+    // 5. Generate STARK proofs for each segment (segmentation is determined by `config`), with
+    //    timer.
     let app_vk = app_pk.get_app_vk();
     let prover =
         AppProver::<VC, E>::new(app_pk.app_vm_pk, committed_exe).with_program_name(bench_name);

crates/circuits/mod-builder/src/builder.rs

@@ -78,12 +78,13 @@ pub struct ExprBuilder {
     /// flag for debug mode
     debug: bool,
 
-    /// Whether the builder has been finalized. Only after finalize, we can do generate_subrow and eval etc.
+    /// Whether the builder has been finalized. Only after finalize, we can do generate_subrow and
+    /// eval etc.
     finalized: bool,
 
     // Setup opcode is a special op that verifies the modulus is correct.
-    // There are some chips that don't need it because we hardcode the modulus. E.g. the pairing ones.
-    // For those chips need setup, setup is derived: setup = is_valid - sum(all_flags)
+    // There are some chips that don't need it because we hardcode the modulus. E.g. the pairing
+    // ones. For those chips need setup, setup is derived: setup = is_valid - sum(all_flags)
     // Therefore when the chip only supports one opcode, user won't explicitly create a flag for it
     // and we will create a default flag for it on finalizing.
     needs_setup: bool,
@@ -185,7 +186,8 @@ impl ExprBuilder {
     // so there should be same number of calls to the new_var, add_constraint and add_compute.
     pub fn new_var(&mut self) -> (usize, SymbolicExpr) {
         self.num_variables += 1;
-        // Allocate space for the new variable, to make sure they are corresponding to the same variable index.
+        // Allocate space for the new variable, to make sure they are corresponding to the same
+        // variable index.
         self.constraints.push(SymbolicExpr::Input(0));
         self.computes.push(SymbolicExpr::Input(0));
         self.q_limbs.push(0);
@@ -349,10 +351,9 @@ impl<AB: InteractionBuilder> SubAir<AB> for FieldExpr {
             builder.assert_bool(is_setup.clone());
             // TODO[jpw]: currently we enforce at the program code level that:
             // - a valid program must call the correct setup opcodes to be correct
-            // - it would be better if we can constraint this in the circuit,
-            //   however this has the challenge that when the same chip is used
-            //   across continuation segments,
-            //   only the first segment will have setup called
+            // - it would be better if we can constraint this in the circuit, however this has the
+            //   challenge that when the same chip is used across continuation segments, only the
+            //   first segment will have setup called
 
             let expected = iter::empty()
                 .chain({
@@ -472,7 +473,8 @@ impl<F: PrimeField64> TraceSubRowGenerator<F> for FieldExpr {
             .collect::<Vec<_>>();
         let zero = OverflowInt::<isize>::from_canonical_unsigned_limbs(vec![0], limb_bits);
         let mut vars_overflow = vec![zero; self.num_variables];
-        // Note: in cases where the prime fits in less limbs than `num_limbs`, we use the smaller number of limbs.
+        // Note: in cases where the prime fits in less limbs than `num_limbs`, we use the smaller
+        // number of limbs.
         let prime_overflow = OverflowInt::<isize>::from_biguint(&self.prime, self.limb_bits, None);
 
         let constants: Vec<_> = self
@@ -493,7 +495,8 @@ impl<F: PrimeField64> TraceSubRowGenerator<F> for FieldExpr {
             vars_overflow[i] =
                 OverflowInt::<isize>::from_biguint(&vars[i], self.limb_bits, Some(self.num_limbs));
         }
-        // We need to have all variables computed first because, e.g. constraints[2] might need variables[3].
+        // We need to have all variables computed first because, e.g. constraints[2] might need
+        // variables[3].
         for i in 0..self.constraints.len() {
             // expr = q * p
             let expr_bigint =

crates/circuits/mod-builder/src/core_chip.rs

@@ -35,7 +35,8 @@ pub struct FieldExpressionCoreAir {
     /// All the opcode indices (including setup) supported by this Air.
     /// The last one must be the setup opcode if it's a chip needs setup.
     pub local_opcode_idx: Vec<usize>,
-    /// Opcode flag idx (indices from builder.new_flag()) for all except setup opcode. Empty if single op chip.
+    /// Opcode flag idx (indices from builder.new_flag()) for all except setup opcode. Empty if
+    /// single op chip.
     pub opcode_flag_idx: Vec<usize>,
     // Example 1: 1-op chip EcAdd that needs setup
     //   local_opcode_idx = [0, 2], where 0 is EcAdd, 2 is setup
@@ -178,7 +179,8 @@ pub struct FieldExpressionCoreChip {
 
     pub name: String,
 
-    /// Whether to finalize the trace. True if all-zero rows don't satisfy the constraints (e.g. there is int_add)
+    /// Whether to finalize the trace. True if all-zero rows don't satisfy the constraints (e.g.
+    /// there is int_add)
     pub should_finalize: bool,
 }
 
@@ -245,8 +247,9 @@ where
         let local_opcode_idx = opcode.local_opcode_idx(self.air.offset);
         let mut flags = vec![];
 
-        // If the chip doesn't need setup, (right now) it must be single op chip and thus no flag is needed.
-        // Otherwise, there is a flag for each opcode and will be derived by is_valid - sum(flags).
+        // If the chip doesn't need setup, (right now) it must be single op chip and thus no flag is
+        // needed. Otherwise, there is a flag for each opcode and will be derived by
+        // is_valid - sum(flags).
         if self.expr().needs_setup() {
             flags = vec![false; self.air.num_flags()];
             self.air

crates/circuits/mod-builder/src/field_variable.rs

@@ -89,7 +89,8 @@ impl FieldVariable {
 
     fn save_if_overflow(
         a: &mut FieldVariable, // will save this variable if overflow
-        expr: SymbolicExpr, // the "compute" expression of the result variable. Note that we need to check if constraint overflows
+        expr: SymbolicExpr,    /* the "compute" expression of the result variable. Note that we
+                                * need to check if constraint overflows */
         limb_max_abs: usize, // The max abs of limbs of compute expression.
     ) {
         if let SymbolicExpr::Var(_) = a.expr {
@@ -115,7 +116,8 @@ impl FieldVariable {
 
     // TODO[Lun-Kai]: rethink about how should auto-save work.
     // This implementation requires self and other to be mutable, and might actually mutate them.
-    // This might surprise the caller or introduce hard bug if the caller clone the FieldVariable and then call this.
+    // This might surprise the caller or introduce hard bug if the caller clone the FieldVariable
+    // and then call this.
     pub fn add(&mut self, other: &mut FieldVariable) -> FieldVariable {
         assert!(Rc::ptr_eq(&self.builder, &other.builder));
         let limb_max_fn = |a: &FieldVariable, b: &FieldVariable| a.limb_max_abs + b.limb_max_abs;

crates/circuits/mod-builder/src/symbolic_expr.rs

@@ -222,7 +222,8 @@ impl SymbolicExpr {
             SymbolicExpr::IntAdd(lhs, s) => {
                 let (lhs_max_pos, lhs_max_neg) = lhs.max_abs(proper_max);
                 let scalar = BigUint::from_usize(s.unsigned_abs()).unwrap();
-                // Optimization opportunity: since `s` is a constant, we can likely do better than this bound.
+                // Optimization opportunity: since `s` is a constant, we can likely do better than
+                // this bound.
                 (lhs_max_pos + &scalar, lhs_max_neg + &scalar)
             }
             SymbolicExpr::IntMul(lhs, s) => {
@@ -243,8 +244,8 @@ impl SymbolicExpr {
     }
 
     /// Returns the maximum possible size, in bits, of each limb in `self.expr`.
-    /// This is already tracked in `FieldVariable`. However when auto saving in `FieldVariable::div`,
-    /// we need to know it from the `SymbolicExpr` only.
+    /// This is already tracked in `FieldVariable`. However when auto saving in
+    /// `FieldVariable::div`, we need to know it from the `SymbolicExpr` only.
     /// self should be a constraint expr.
     pub fn constraint_limb_max_abs(&self, limb_bits: usize, num_limbs: usize) -> usize {
         let canonical_limb_max_abs = (1 << limb_bits) - 1;

crates/circuits/mod-builder/src/tests.rs

@@ -135,8 +135,8 @@ fn test_auto_carry_intmul() {
     let mut x3 = &mut x1 * &mut x2;
     // The int_mul below will overflow:
     // x3 should have max_overflow_bits = 8 + 8 + log2(32) = 21
-    // The carry bits = "max_overflow_bits - limb_bits + 1" will exceed 17 if it exceeds 17 + 8 - 1 = 24.
-    // So it triggers x3 to be saved first.
+    // The carry bits = "max_overflow_bits - limb_bits + 1" will exceed 17 if it exceeds 17 + 8 - 1
+    // = 24. So it triggers x3 to be saved first.
     let mut x4 = x3.int_mul(9);
     assert_eq!(x3.expr, SymbolicExpr::Var(0));
     x4.save();
@@ -229,7 +229,8 @@ fn test_auto_carry_div() {
     let x2 = ExprBuilder::new_input(builder.clone());
     // The choice of scalar (7) needs to be such that
     // 1. the denominator 7x^2 doesn't trigger autosave, >=8 doesn't work.
-    // 2. But doing a division on it triggers autosave, because of division constraint, <= 6 doesn't work.
+    // 2. But doing a division on it triggers autosave, because of division constraint, <= 6 doesn't
+    //    work.
     let mut x3 = x1.square().int_mul(7) / x2;
     x3.save();
 
@@ -387,8 +388,9 @@ fn test_symbolic_limbs_mul() {
         Box::new(SymbolicExpr::Var(0)),
         Box::new(SymbolicExpr::Var(1)),
     );
-    // x * y = pq, and x,y can be up to 2^256 - 1 so q can be up to ceil((2^256 - 1)^2 / p) which has 257 bits, which is 33 limbs
-    // x * y has 63 limbs, but p * q can have 64 limbs since q is 33 limbs
+    // x * y = pq, and x,y can be up to 2^256 - 1 so q can be up to ceil((2^256 - 1)^2 / p) which
+    // has 257 bits, which is 33 limbs x * y has 63 limbs, but p * q can have 64 limbs since q
+    // is 33 limbs
     let expected_q = 33;
     let expected_carry = 64;
     test_symbolic_limbs(expr, expected_q, expected_carry);

crates/circuits/poseidon2-air/src/config.rs

@@ -8,7 +8,8 @@ use super::{
     BABY_BEAR_POSEIDON2_HALF_FULL_ROUNDS, BABY_BEAR_POSEIDON2_PARTIAL_ROUNDS, POSEIDON2_WIDTH,
 };
 
-// Currently only contains round constants, but this struct may contain other configuration parameters in the future.
+// Currently only contains round constants, but this struct may contain other configuration
+// parameters in the future.
 #[derive(Clone, Copy, Debug)]
 pub struct Poseidon2Config<F> {
     pub constants: Poseidon2Constants<F>,

crates/circuits/poseidon2-air/src/lib.rs

@@ -2,7 +2,8 @@
 //! get around some complications with field-specific generics associated with Poseidon2.
 //! Currently it is only intended for use in OpenVM with BabyBear.
 //!
-//! We do not recommend external use of this crate, and suggest using the [p3_poseidon2_air] crate directly.
+//! We do not recommend external use of this crate, and suggest using the [p3_poseidon2_air] crate
+//! directly.
 
 use std::sync::Arc;
 
@@ -39,7 +40,8 @@ pub const BABY_BEAR_POSEIDON2_PARTIAL_ROUNDS: usize = 13;
 // Currently we only support SBOX_DEGREE = 7
 pub const BABY_BEAR_POSEIDON2_SBOX_DEGREE: u64 = 7;
 
-/// `SBOX_REGISTERS` affects the max constraint degree of the AIR. See [p3_poseidon2_air] for more details.
+/// `SBOX_REGISTERS` affects the max constraint degree of the AIR. See [p3_poseidon2_air] for more
+/// details.
 #[derive(Debug)]
 pub struct Poseidon2SubChip<F: Field, const SBOX_REGISTERS: usize> {
     // This is Arc purely because Poseidon2Air cannot derive Clone

crates/circuits/poseidon2-air/src/permute.rs

@@ -18,14 +18,16 @@ pub trait Poseidon2MatrixConfig: Clone + Sync {
     fn int_diag_m1_matrix<F: FieldAlgebra>() -> [F; WIDTH];
 }
 
-/// This type needs to implement GenericPoseidon2LinearLayers generic in F so that our Poseidon2SubAir can also
-/// be generic in F, but in reality each implementation of this struct's functions should be field specific. To
-/// circumvent this, Poseidon2LinearLayers is generic in F but **currently requires** that F is BabyBear.
+/// This type needs to implement GenericPoseidon2LinearLayers generic in F so that our
+/// Poseidon2SubAir can also be generic in F, but in reality each implementation of this struct's
+/// functions should be field specific. To circumvent this, Poseidon2LinearLayers is generic in F
+/// but **currently requires** that F is BabyBear.
 #[derive(Debug, Clone)]
 pub struct BabyBearPoseidon2LinearLayers;
 
-// This is the same as the implementation for GenericPoseidon2LinearLayersMonty31<BabyBearParameters, BabyBearInternalLayerParameters> except that we drop the
-// clause that FA needs be multipliable by BabyBear.
+// This is the same as the implementation for
+// GenericPoseidon2LinearLayersMonty31<BabyBearParameters, BabyBearInternalLayerParameters> except
+// that we drop the clause that FA needs be multipliable by BabyBear.
 // TODO[jpw/stephen]: This is clearly not the best way to do this, but it would
 // require some reworking in plonky3 to get around the generics.
 impl<FA: FieldAlgebra> GenericPoseidon2LinearLayers<FA, WIDTH> for BabyBearPoseidon2LinearLayers {