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 {

crates/circuits/primitives/derive/src/lib.rs

@@ -38,7 +38,8 @@ pub fn aligned_borrow_derive(input: TokenStream) -> TokenStream {
         })
         .collect::<Vec<_>>();
 
-    // Get impl generics (`<T, N: NumLimbs, const M: usize>`), type generics (`<T, N>`), where clause (`where T: Clone`)
+    // Get impl generics (`<T, N: NumLimbs, const M: usize>`), type generics (`<T, N>`), where
+    // clause (`where T: Clone`)
     let (impl_generics, type_generics, where_clause) = ast.generics.split_for_impl();
 
     let methods = quote! {
@@ -331,8 +332,8 @@ pub fn bytes_stateful_derive(input: TokenStream) -> TokenStream {
                 }
                 _ => panic!("Only unnamed fields are supported"),
             };
-            // Use full path ::openvm_circuit... so it can be used either within or outside the vm crate.
-            // Assume F is already generic of the field.
+            // Use full path ::openvm_circuit... so it can be used either within or outside the vm
+            // crate. Assume F is already generic of the field.
             let mut new_generics = generics.clone();
             let where_clause = new_generics.make_where_clause();
             where_clause
@@ -365,7 +366,8 @@ pub fn bytes_stateful_derive(input: TokenStream) -> TokenStream {
                     (variant_name, field)
                 })
                 .collect::<Vec<_>>();
-            // Use full path ::openvm_stark_backend... so it can be used either within or outside the vm crate.
+            // Use full path ::openvm_stark_backend... so it can be used either within or outside
+            // the vm crate.
             let (load_state_arms, store_state_arms): (Vec<_>, Vec<_>) =
                 multiunzip(variants.iter().map(|(variant_name, field)| {
                     let field_ty = &field.ty;

crates/circuits/primitives/src/assert_less_than/mod.rs

@@ -131,10 +131,11 @@ impl AssertLtSubAir {
             });
 
         // constrain that y - x - 1 is equal to the constructed lower value.
-        // this enforces that the intermediate value is in the range [0, 2^max_bits - 1], which is equivalent to x < y
+        // this enforces that the intermediate value is in the range [0, 2^max_bits - 1], which is
+        // equivalent to x < y
         builder.when(io.count).assert_eq(intermed_val, lower);
-        // the degree of this constraint is expected to be deg(count) + max(deg(intermed_val), deg(lower))
-        // since we are constraining count * intermed_val == count * lower
+        // the degree of this constraint is expected to be deg(count) + max(deg(intermed_val),
+        // deg(lower)) since we are constraining count * intermed_val == count * lower
     }
 
     #[inline(always)]
@@ -185,7 +186,8 @@ impl<AB: InteractionBuilder> SubAir<AB> for AssertLtSubAir {
 
 impl<F: Field> TraceSubRowGenerator<F> for AssertLtSubAir {
     /// (range_checker, x, y)
-    // x, y are u32 because memory records are storing u32 and there would be needless conversions. It also prevents a F: PrimeField32 trait bound.
+    // x, y are u32 because memory records are storing u32 and there would be needless conversions.
+    // It also prevents a F: PrimeField32 trait bound.
     type TraceContext<'a> = (&'a VariableRangeCheckerChip, u32, u32);
     /// lower_decomp
     type ColsMut<'a> = &'a mut [F];

crates/circuits/primitives/src/bigint/check_carry_mod_to_zero.rs

@@ -18,8 +18,8 @@ pub struct CheckCarryModToZeroCols<T> {
     pub carries: Vec<T>,
 
     // We will check that expr - quotient * modulus = 0, which imples expr is 0 mod modulus.
-    // quotient can be negative, and this means there is no unique way to represent it as limbs but it's fine.
-    // Each limb will be range-checked to be in [-2^limb_bits, 2^limb_bits).
+    // quotient can be negative, and this means there is no unique way to represent it as limbs but
+    // it's fine. Each limb will be range-checked to be in [-2^limb_bits, 2^limb_bits).
     pub quotient: Vec<T>,
 }
 

crates/circuits/primitives/src/bigint/mod.rs

@@ -36,7 +36,8 @@ impl<T> OverflowInt<T> {
         }
     }
 
-    // Limbs can be negative. So the max_overflow_bits and limb_max_abs are different from the range check result.
+    // Limbs can be negative. So the max_overflow_bits and limb_max_abs are different from the range
+    // check result.
     pub fn from_canonical_signed_limbs(x: Vec<T>, limb_bits: usize) -> OverflowInt<T> {
         OverflowInt {
             limbs: x,

crates/circuits/primitives/src/encoder/mod.rs

@@ -20,7 +20,8 @@ pub struct Encoder {
     /// The number of flags, excluding the invalid/dummy flag.
     flag_cnt: usize,
     /// Maximal degree of the flag expressions.
-    /// The maximal degree of the equalities in the AIR, however, **is one higher:** that is, `max_flag_degree + 1`.
+    /// The maximal degree of the equalities in the AIR, however, **is one higher:** that is,
+    /// `max_flag_degree + 1`.
     max_flag_degree: u32,
     /// All possible points in the k-dimensional space that can be used to encode flags
     pts: Vec<Vec<u32>>,
@@ -34,7 +35,8 @@ impl Encoder {
     /// The zero point is reserved for the dummy row.
     /// `max_degree` is the upper bound for the flag expressions, but the `eval` function
     /// of the encoder itself will use some constraints of degree `max_degree + 1`.
-    /// `reserve_invalid` indicates if the encoder should reserve the (0, ..., 0) point as an invalid/dummy flag.
+    /// `reserve_invalid` indicates if the encoder should reserve the (0, ..., 0) point as an
+    /// invalid/dummy flag.
     pub fn new(cnt: usize, max_degree: u32, reserve_invalid: bool) -> Self {
         // Calculate binomial coefficient (d+k choose k) to determine how many points we can encode
         let binomial = |x: u32| {
@@ -109,7 +111,8 @@ impl Encoder {
         expr * denom.inverse()
     }
 
-    /// Get the polynomial expression that equals 1 when the variables encode the flag at index flag_idx
+    /// Get the polynomial expression that equals 1 when the variables encode the flag at index
+    /// flag_idx
     pub fn get_flag_expr<AB: InteractionBuilder>(
         &self,
         flag_idx: usize,
@@ -125,7 +128,8 @@ impl Encoder {
         self.pts[flag_idx + self.reserve_invalid as usize].clone()
     }
 
-    /// Returns an expression that is 1 if the variables encode a valid flag and 0 if they encode the invalid point
+    /// Returns an expression that is 1 if the variables encode a valid flag and 0 if they encode
+    /// the invalid point
     pub fn is_valid<AB: InteractionBuilder>(&self, vars: &[AB::Var]) -> AB::Expr {
         AB::Expr::ONE - self.expression_for_point::<AB>(&self.pts[0], vars)
     }