misc: formatting fixes

Author: kaimast

algorithms/src/snark/varuna/ahp/prover/round_functions/third.rs

@@ -271,7 +271,6 @@ impl<F: PrimeField, SM: SNARKMode> AHPForR1CS<F, SM> {
             .map(|((circuit, circuit_specific_state), w_polys)| {
                 let x_polys = &circuit_specific_state.x_polys;
                 let input_domain = &circuit_specific_state.input_domain;
-
                 let assignments_i: Vec<_> = cfg_iter!(w_polys)
                     .zip_eq(x_polys)
                     .enumerate()

utilities/src/errors.rs

@@ -41,8 +41,8 @@ pub fn into_io_error<E: Into<anyhow::Error>>(err: E) -> std::io::Error {
 }
 
 /// Helper function for `log_error` and `log_warning`.
-#[inline]
 #[track_caller]
+#[inline]
 fn flatten_anyhow_error<E: Borrow<anyhow::Error>>(error: E) -> String {
     let error = error.borrow();
 
@@ -57,8 +57,8 @@ fn flatten_anyhow_error<E: Borrow<anyhow::Error>>(error: E) -> String {
 /// This follows the existing convention in the codebase that joins errors using em dashes.
 /// For example, an error "Invalid transaction" with a cause "Proof failed" would be logged
 /// as "Invalid transaction — Proof failed".
-#[inline]
 #[track_caller]
+#[inline]
 pub fn log_error<E: Borrow<anyhow::Error>>(error: E) {
     tracing::error!("{}", flatten_anyhow_error(error));
 }
@@ -68,17 +68,17 @@ pub fn log_error<E: Borrow<anyhow::Error>>(error: E) {
 /// This follows the existing convention in the codebase that joins errors using em dashes.
 /// For example, an error "Invalid transaction" with a cause "Proof failed" would be logged
 /// as "Invalid transaction — Proof failed".
-#[inline]
 #[track_caller]
+#[inline]
 pub fn log_warning<E: Borrow<anyhow::Error>>(error: E) {
     tracing::warn!("{}", flatten_anyhow_error(error));
 }
 
 /// Displays an `anyhow::Error`'s main error and its error chain to stderr.
 ///
 /// This can be used to show a "pretty" error to the end user.
-#[inline]
 #[track_caller]
+#[inline]
 pub fn display_error<E: Borrow<anyhow::Error>>(error: E) {
     let error = error.borrow();
     eprintln!("⚠️ {error}");
@@ -125,24 +125,24 @@ pub trait LoggableError {
 
 impl<E: Into<anyhow::Error>> LoggableError for E {
     /// Log the error with the given context and log level `ERROR`.
-    #[inline]
     #[track_caller]
+    #[inline]
     fn log_error<S: Send + Sync + Display + 'static>(self, context: S) {
         let err: anyhow::Error = self.into();
         log_error(err.context(context));
     }
 
     /// Log the error with the given context and log level `WARNING`.
-    #[inline]
     #[track_caller]
+    #[inline]
     fn log_warning<S: Send + Sync + Display + 'static>(self, context: S) {
         let err: anyhow::Error = self.into();
         log_warning(err.context(context));
     }
 
     /// Log the error with the given context and log level `DEBUG`.
-    #[inline]
     #[track_caller]
+    #[inline]
     fn log_debug<S: Send + Sync + Display + 'static>(self, context: S) {
         let err: anyhow::Error = self.into();
         log_warning(err.context(context));
@@ -183,6 +183,7 @@ impl<T> PrettyUnwrap for anyhow::Result<T> {
     type Inner = T;
 
     #[track_caller]
+    #[inline]
     fn pretty_unwrap(self) -> Self::Inner {
         match self {
             Ok(result) => result,
@@ -198,8 +199,8 @@ impl<T> PrettyUnwrap for anyhow::Result<T> {
 /// In debug mode, it prints to stderr using the format: "VM safely halted at {location}: {halt message}".
 ///
 /// Note: For this to work as expected, panics must be set to `unwind` during compilation (default), and the closure cannot invoke any async code that may potentially execute in a different OS thread.
-#[inline]
 #[track_caller]
+#[inline]
 pub fn try_vm_runtime<R, F: FnMut() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     // Perform the operation that may panic.
     let result = std::panic::catch_unwind(panic::AssertUnwindSafe(f));
@@ -234,6 +235,7 @@ pub fn try_vm_runtime<R, F: FnMut() -> R>(f: F) -> Result<R, Box<dyn Any + Send>
 }
 
 /// `catch_unwind` calls the given closure `f` and, if `f` panics, returns the panic message and backtrace.
+#[inline]
 pub fn catch_unwind<R, F: FnMut() -> R>(f: F) -> Result<R, (String, Backtrace)> {
     // Perform the operation that may panic.
     std::panic::catch_unwind(panic::AssertUnwindSafe(f)).map_err(|_| {