cargo-fmt for 2024 edition

Author: baflor

src/cli/concolic_explore.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ir::{Location, ModuleSpec},
     HashSet,
+    ir::{Location, ModuleSpec},
 };
 use std::{cell::RefCell, collections::VecDeque, rc::Rc, sync::Arc};
 
@@ -202,7 +202,7 @@ impl<'a> ConcolicExplorer<'a> {
         for (event_idx, event) in trace.events.iter().enumerate() {
             // TODO: what about other events?
             dbg!(event);
-            if let ConcolicEvent::PathConstraint {  .. } = *event {
+            if let ConcolicEvent::PathConstraint { .. } = *event {
                 // if location == loc || true { // TODO
                 self.wq.push_back(Work::CheckSatNoConstraints {
                     trace_idx,

src/cli/cov_html.rs

@@ -1,6 +1,6 @@
+use crate::HashMap;
 use crate::instrumentation::BBCoveragePass;
 use crate::ir::debuginfo_helper::resolve_source_location;
-use crate::HashMap;
 use std::collections::BTreeSet;
 use std::fmt::Write;
 use std::path::PathBuf;
@@ -11,10 +11,10 @@ use clap::Parser;
 use askama::Template;
 use symbolic::debuginfo::{Object, ObjectError};
 use syntect::highlighting::ThemeSet;
-use syntect::html::{css_for_theme_with_class_style, ClassStyle};
+use syntect::html::{ClassStyle, css_for_theme_with_class_style};
 use syntect::parsing::{
-    BasicScopeStackOp, ParseState, Scope, ScopeRepository, ScopeStack, SyntaxReference, SyntaxSet,
-    SCOPE_REPO,
+    BasicScopeStackOp, ParseState, SCOPE_REPO, Scope, ScopeRepository, ScopeStack, SyntaxReference,
+    SyntaxSet,
 };
 use syntect::util::LinesWithEndings;
 

src/cli/lcov.rs

@@ -2,8 +2,8 @@
 //              this suggest that high line coverage accuracy should be possible for -O0 (fig 10):
 //              https://arxiv.org/abs/2402.04811v1
 
-use crate::instrumentation::BBCoveragePass;
 use crate::HashMap;
+use crate::instrumentation::BBCoveragePass;
 use std::path::PathBuf;
 use std::sync::Arc;
 

src/cli/monitor_cov.rs

@@ -1,8 +1,8 @@
 use crate::{
+    HashSet,
     instrumentation::{
         BBCoveragePass, CodeCovInstrumentationPass, EdgeCoveragePass, FunctionCoveragePass,
     },
-    HashSet,
 };
 use std::{
     io::Write,

src/concolic/bitwuzla_backend.rs

@@ -1,10 +1,10 @@
 // TODO(concolic): concretization policies in style of https://github.com/trailofbits/manticore/blob/master/manticore/core/state.py#L387
 
-use crate::{ir::ModuleSpec, HashMap, HashSet};
+use crate::{HashMap, HashSet, ir::ModuleSpec};
 use std::{rc::Rc, sync::Arc, time::Duration};
 
 use bitvec::slice::BitSlice;
-use bitwuzla::{Bool, Btor, RoundingMode, SolverResult, BV, FP};
+use bitwuzla::{BV, Bool, Btor, FP, RoundingMode, SolverResult};
 
 use crate::concolic::MemoryAccessKind;
 

src/concolic/mod.rs

@@ -342,7 +342,7 @@ impl MemoryAccessKind {
         opcode: cranelift::codegen::ir::Opcode,
         ty: cranelift::prelude::Type,
     ) -> Self {
-        use cranelift::codegen::ir::{types, Opcode};
+        use cranelift::codegen::ir::{Opcode, types};
         match (opcode, ty) {
             (Opcode::Load, types::I32) => Self::I32,
             (Opcode::Load, types::I64) => Self::I64,

src/concolic/ops.rs

@@ -1,8 +1,8 @@
 use speedy::{Readable, Writable};
 
 use crate::ir::{
-    operators::{ConversionOp, FRelOp},
     FBinaryOp, FUnaryOp, IBinaryOp, IRelOp, ITestOp, IUnaryOp,
+    operators::{ConversionOp, FRelOp},
 };
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Readable, Writable)]

src/concolic/smtlib_backend.rs

@@ -1,4 +1,4 @@
-use crate::{ir::ModuleSpec, HashMap, HashSet};
+use crate::{HashMap, HashSet, ir::ModuleSpec};
 use std::sync::Arc;
 
 use crate::concolic::MemoryAccessKind;
@@ -8,9 +8,9 @@ use super::{BinaryOp, ConcolicEvent, SolverBackendError, SymVal, SymValRef, Symv
 
 use smtlib::Logic;
 use smtlib::{
+    BitVec, Bool, SatResult,
     prelude::*,
     terms::{Const, Dynamic},
-    BitVec, Bool, SatResult,
 };
 
 #[derive(Clone, Debug)]
@@ -134,12 +134,10 @@ impl<'ctx> SolverInstance<'ctx> {
     }
 
     fn get_inp_bv(&mut self, i: u16) -> Const<'ctx, BitVec<'ctx, 8>> {
-        *self.inp_vals
-            .entry(i)
-            .or_insert_with(|| {
-                let symbol = format!("inp-{i}");
-                BitVec::new_const(self.storage, &symbol)
-            })
+        *self.inp_vals.entry(i).or_insert_with(|| {
+            let symbol = format!("inp-{i}");
+            BitVec::new_const(self.storage, &symbol)
+        })
     }
 
     fn new_prop(&mut self) -> Const<'ctx, Bool<'ctx>> {
@@ -193,7 +191,7 @@ impl<'ctx> SolverInstance<'ctx> {
             SymVal::ConstI32(v) => BitVec::<32>::new(self.storage, v as i64).into(),
             SymVal::ConstI64(v) => BitVec::<64>::new(self.storage, v as i64).into(),
             SymVal::ConstF32(_) | SymVal::ConstF64(_) => {
-                return Err(SolverBackendError::UnsupportedFloatingpointOperation)
+                return Err(SolverBackendError::UnsupportedFloatingpointOperation);
             }
             SymVal::Unary(op, bv) => {
                 let val = self.get_symval(bv, context)?;
@@ -268,7 +266,7 @@ impl<'ctx> SolverInstance<'ctx> {
                     MemoryAccessKind::I64AsS32 => combine_32(&bytes).sext::<32, 64>().into(),
                     MemoryAccessKind::I64AsU32 => combine_32(&bytes).uext::<32, 64>().into(),
                     MemoryAccessKind::F32 | MemoryAccessKind::F64 => {
-                        return Err(SolverBackendError::UnsupportedFloatingpointOperation)
+                        return Err(SolverBackendError::UnsupportedFloatingpointOperation);
                     }
                 }
                 // zero-width bvs are not allowed :(

src/concolic/z3_backend.rs

@@ -3,8 +3,8 @@ use std::sync::Arc;
 
 use bitvec::slice::BitSlice;
 use z3::{
-    ast::{Ast, Bool, Dynamic, Float, BV},
     SatResult, Solver, Symbol,
+    ast::{Ast, BV, Bool, Dynamic, Float},
 };
 
 use crate::{concolic::MemoryAccessKind, ir::ModuleSpec};

src/fuzzer/exhaustive.rs

@@ -1,4 +1,4 @@
-use rand::{seq::SliceRandom, Rng};
+use rand::{Rng, seq::SliceRandom};
 
 pub trait QueuedInputMutation {
     fn input(&self) -> &[u8];