fix: clippy (#2519)

leruaa · web-flow · commit 15b274359964 · 2025-12-15T18:23:59.000+01:00
diff --git a/crates/core/executor/src/disassembler/elf.rs b/crates/core/executor/src/disassembler/elf.rs
@@ -82,7 +82,7 @@ impl Elf {
         }
 
         let mut instructions: Vec<u32> = Vec::new();
-        let mut base_address = None;
+        let mut base_address: Option<u32> = None;
 
         // Data about the last segment.
         let mut prev_segment_end_addr = None;
@@ -136,23 +136,22 @@ impl Elf {
                 Some(vaddr.checked_add(mem_size).ok_or_eyre("last addr overflow")?);
 
             if (segment.p_flags & PF_X) != 0 {
-                if base_address.is_none() {
-                    base_address = Some(vaddr);
-                    eyre::ensure!(
-                        base_address.unwrap() > 0x20,
-                        "base address {} should be greater than 0x20",
-                        base_address.unwrap()
-                    );
-                } else {
+                if let Some(base_address) = base_address {
                     let instr_len: u32 = WORD_SIZE
                         .checked_mul(instructions.len())
                         .ok_or_eyre("instructions length overflow")?
                         .try_into()?;
                     let last_instruction_addr = base_address
-                        .unwrap()
                         .checked_add(instr_len)
                         .ok_or_eyre("instruction addr overflow")?;
                     eyre::ensure!(vaddr == last_instruction_addr, "unsupported elf structure");
+                } else {
+                    base_address = Some(vaddr);
+                    eyre::ensure!(
+                        base_address.unwrap() > 0x20,
+                        "base address {} should be greater than 0x20",
+                        base_address.unwrap()
+                    );
                 }
             }
 
diff --git a/crates/core/executor/src/syscalls/unconstrained.rs b/crates/core/executor/src/syscalls/unconstrained.rs
@@ -12,7 +12,7 @@ impl Syscall for EnterUnconstrainedSyscall {
             panic!("Unconstrained block is already active.");
         }
         ctx.rt.unconstrained = true;
-        ctx.rt.unconstrained_state = Box::new(ForkState {
+        *ctx.rt.unconstrained_state = ForkState {
             global_clk: ctx.rt.state.global_clk,
             clk: ctx.rt.state.clk,
             pc: ctx.rt.state.pc,
@@ -21,7 +21,7 @@ impl Syscall for EnterUnconstrainedSyscall {
             op_record: std::mem::take(&mut ctx.rt.memory_accesses),
             executor_mode: ctx.rt.executor_mode,
             total_unconstrained_cycles: ctx.rt.unconstrained_state.total_unconstrained_cycles,
-        });
+        };
         ctx.rt.executor_mode = ExecutorMode::Simple;
         Some(1)
     }
@@ -55,7 +55,7 @@ impl Syscall for ExitUnconstrainedSyscall {
             ctx.rt.unconstrained = false;
         }
 
-        ctx.rt.unconstrained_state = Box::new(ForkState::default());
+        *ctx.rt.unconstrained_state = ForkState::default();
         // Persist the total number of unconstrained cycles.
         ctx.rt.unconstrained_state.total_unconstrained_cycles = total_unconstrained_cycles;
 
diff --git a/crates/core/machine/src/alu/add_sub/mod.rs b/crates/core/machine/src/alu/add_sub/mod.rs
@@ -464,8 +464,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a;
                     }
diff --git a/crates/core/machine/src/alu/bitwise/mod.rs b/crates/core/machine/src/alu/bitwise/mod.rs
@@ -333,8 +333,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a;
                     }
diff --git a/crates/core/machine/src/alu/divrem/mod.rs b/crates/core/machine/src/alu/divrem/mod.rs
@@ -977,8 +977,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a;
                     }
diff --git a/crates/core/machine/src/alu/lt/mod.rs b/crates/core/machine/src/alu/lt/mod.rs
@@ -601,8 +601,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a as u32;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a as u32;
                     }
diff --git a/crates/core/machine/src/alu/mul/mod.rs b/crates/core/machine/src/alu/mul/mod.rs
@@ -645,8 +645,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a as u32;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a as u32;
                     }
diff --git a/crates/core/machine/src/alu/sll/mod.rs b/crates/core/machine/src/alu/sll/mod.rs
@@ -530,8 +530,8 @@ mod tests {
                       -> Vec<(String, RowMajorMatrix<Val<BabyBearPoseidon2>>)> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a as u32;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a as u32;
                     }
diff --git a/crates/core/machine/src/alu/sr/mod.rs b/crates/core/machine/src/alu/sr/mod.rs
@@ -672,8 +672,8 @@ mod tests {
                 )> {
                     let mut malicious_record = record.clone();
                     malicious_record.cpu_events[0].a = op_a as u32;
-                    if let Some(MemoryRecordEnum::Write(mut write_record)) =
-                        malicious_record.cpu_events[0].a_record
+                    if let Some(MemoryRecordEnum::Write(write_record)) =
+                        malicious_record.cpu_events[0].a_record.as_mut()
                     {
                         write_record.value = op_a as u32;
                     }
diff --git a/crates/core/machine/src/operations/add.rs b/crates/core/machine/src/operations/add.rs
@@ -19,6 +19,7 @@ pub struct AddOperation<T> {
 }
 
 impl<F: Field> AddOperation<F> {
+    #[allow(unused_assignments)]
     pub fn populate(&mut self, record: &mut impl ByteRecord, a_u32: u32, b_u32: u32) -> u32 {
         let expected = a_u32.wrapping_add(b_u32);
         self.value = Word::from(expected);
diff --git a/crates/eval/src/lib.rs b/crates/eval/src/lib.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use clap::{command, Parser};
+use clap::Parser;
 use reqwest::Client;
 use serde::Serialize;
 use serde_json::json;
diff --git a/crates/perf/src/executor.rs b/crates/perf/src/executor.rs
@@ -1,6 +1,6 @@
 use std::time::{Duration, Instant};
 
-use clap::{command, Parser};
+use clap::Parser;
 use p3_baby_bear::BabyBear;
 use sp1_core_executor::{Executor, ExecutorMode, Program};
 use sp1_core_machine::shape::CoreShapeConfig;
diff --git a/crates/perf/src/main.rs b/crates/perf/src/main.rs
@@ -1,6 +1,6 @@
 use std::time::{Duration, Instant};
 
-use clap::{command, Parser};
+use clap::Parser;
 use rand::Rng;
 use sp1_cuda::{MoongateServer, SP1CudaProver};
 use sp1_prover::{components::CpuProverComponents, HashableKey, ProverMode};
diff --git a/crates/sdk/src/network/prover.rs b/crates/sdk/src/network/prover.rs
@@ -516,11 +516,7 @@ impl NetworkProver {
             }
             let remaining_timeout = timeout.map(|t| {
                 let elapsed = start_time.elapsed();
-                if elapsed < t {
-                    t - elapsed
-                } else {
-                    Duration::from_secs(0)
-                }
+                t.checked_sub(elapsed).unwrap_or_default()
             });
 
             let (maybe_proof, fulfillment_status) =

Original file line number	Diff line number	Diff line change
`@@ -464,8 +464,8 @@ mod tests {`
`464`	`464`	`)> {`
`465`	`465`	`let mut malicious_record = record.clone();`
`466`	`466`	`malicious_record.cpu_events[0].a = op_a;`
`467`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`468`		`- malicious_record.cpu_events[0].a_record`
	`467`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`468`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`469`	`469`	`{`
`470`	`470`	`write_record.value = op_a;`
`471`	`471`	`}`
Original file line number	Diff line number	Diff line change
`@@ -333,8 +333,8 @@ mod tests {`
`333`	`333`	`)> {`
`334`	`334`	`let mut malicious_record = record.clone();`
`335`	`335`	`malicious_record.cpu_events[0].a = op_a;`
`336`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`337`		`- malicious_record.cpu_events[0].a_record`
	`336`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`337`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`338`	`338`	`{`
`339`	`339`	`write_record.value = op_a;`
`340`	`340`	`}`
Original file line number	Diff line number	Diff line change
`@@ -977,8 +977,8 @@ mod tests {`
`977`	`977`	`)> {`
`978`	`978`	`let mut malicious_record = record.clone();`
`979`	`979`	`malicious_record.cpu_events[0].a = op_a;`
`980`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`981`		`- malicious_record.cpu_events[0].a_record`
	`980`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`981`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`982`	`982`	`{`
`983`	`983`	`write_record.value = op_a;`
`984`	`984`	`}`
Original file line number	Diff line number	Diff line change
`@@ -601,8 +601,8 @@ mod tests {`
`601`	`601`	`)> {`
`602`	`602`	`let mut malicious_record = record.clone();`
`603`	`603`	`malicious_record.cpu_events[0].a = op_a as u32;`
`604`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`605`		`- malicious_record.cpu_events[0].a_record`
	`604`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`605`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`606`	`606`	`{`
`607`	`607`	`write_record.value = op_a as u32;`
`608`	`608`	`}`
Original file line number	Diff line number	Diff line change
`@@ -645,8 +645,8 @@ mod tests {`
`645`	`645`	`)> {`
`646`	`646`	`let mut malicious_record = record.clone();`
`647`	`647`	`malicious_record.cpu_events[0].a = op_a as u32;`
`648`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`649`		`- malicious_record.cpu_events[0].a_record`
	`648`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`649`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`650`	`650`	`{`
`651`	`651`	`write_record.value = op_a as u32;`
`652`	`652`	`}`
Original file line number	Diff line number	Diff line change
`@@ -530,8 +530,8 @@ mod tests {`
`530`	`530`	`-> Vec<(String, RowMajorMatrix<Val<BabyBearPoseidon2>>)> {`
`531`	`531`	`let mut malicious_record = record.clone();`
`532`	`532`	`malicious_record.cpu_events[0].a = op_a as u32;`
`533`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`534`		`- malicious_record.cpu_events[0].a_record`
	`533`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`534`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`535`	`535`	`{`
`536`	`536`	`write_record.value = op_a as u32;`
`537`	`537`	`}`
Original file line number	Diff line number	Diff line change
`@@ -672,8 +672,8 @@ mod tests {`
`672`	`672`	`)> {`
`673`	`673`	`let mut malicious_record = record.clone();`
`674`	`674`	`malicious_record.cpu_events[0].a = op_a as u32;`
`675`		`- if let Some(MemoryRecordEnum::Write(mut write_record)) =`
`676`		`- malicious_record.cpu_events[0].a_record`
	`675`	`+ if let Some(MemoryRecordEnum::Write(write_record)) =`
	`676`	`+ malicious_record.cpu_events[0].a_record.as_mut()`
`677`	`677`	`{`
`678`	`678`	`write_record.value = op_a as u32;`
`679`	`679`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ pub struct AddOperation<T> {`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`impl<F: Field> AddOperation<F> {`
	`22`	`+ #[allow(unused_assignments)]`
`22`	`23`	`pub fn populate(&mut self, record: &mut impl ByteRecord, a_u32: u32, b_u32: u32) -> u32 {`
`23`	`24`	`let expected = a_u32.wrapping_add(b_u32);`
`24`	`25`	`self.value = Word::from(expected);`