From a688c8b03ddebd665f5deb2c769635057cfdf317 Mon Sep 17 00:00:00 2001 From: Jack Grigg Date: Thu, 25 Feb 2021 20:34:07 +0000 Subject: [PATCH] sha256: Fix / silence lints --- examples/sha256/benches.rs | 8 ++++--- examples/sha256/table16.rs | 5 ++++- examples/sha256/table16/compression.rs | 3 +++ .../table16/compression/compression_gates.rs | 11 ++++++++++ .../table16/compression/compression_util.rs | 4 ++++ .../table16/compression/subregion_digest.rs | 1 + .../table16/compression/subregion_initial.rs | 2 ++ .../table16/compression/subregion_main.rs | 1 + examples/sha256/table16/message_schedule.rs | 13 ++++++++---- .../message_schedule/schedule_gates.rs | 21 +++++++++++++------ .../table16/message_schedule/schedule_util.rs | 15 ++++++++----- .../table16/message_schedule/subregion1.rs | 8 +++---- .../table16/message_schedule/subregion2.rs | 17 ++++++++------- .../table16/message_schedule/subregion3.rs | 10 +++++---- examples/sha256/table16/spread_table.rs | 4 ++-- examples/sha256/table16/util.rs | 10 ++++----- 16 files changed, 91 insertions(+), 42 deletions(-) diff --git a/examples/sha256/benches.rs b/examples/sha256/benches.rs index 2ac5501..0fb30bf 100644 --- a/examples/sha256/benches.rs +++ b/examples/sha256/benches.rs @@ -21,6 +21,7 @@ use criterion::{criterion_group, criterion_main, Criterion}; use crate::{BlockWord, Sha256, Table16Chip, Table16Config, BLOCK_SIZE}; +#[allow(dead_code)] fn bench(name: &str, k: u32, c: &mut Criterion) { struct MyCircuit {} @@ -72,7 +73,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { // Initialize the polynomial commitment parameters let params_path = Path::new("./benches/sha256_assets/sha256_params"); - if let Err(_) = File::open(¶ms_path) { + if File::open(¶ms_path).is_err() { let params: Params = Params::new(k); let mut buf = Vec::new(); @@ -91,7 +92,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { // Initialize the proving key let vk_path = Path::new("./benches/sha256_assets/sha256_vk"); - if let Err(_) = File::open(&vk_path) { + if File::open(&vk_path).is_err() { let vk = keygen_vk(¶ms, &empty_circuit).expect("keygen_vk should not fail"); let mut buf = Vec::new(); @@ -126,7 +127,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { // Create a proof let proof_path = Path::new("./benches/sha256_assets/sha256_proof"); - if let Err(_) = File::open(&proof_path) { + if File::open(&proof_path).is_err() { let mut transcript = Blake2bWrite::init(vec![]); create_proof(¶ms, &pk, &[circuit], &[], &mut transcript) .expect("proof generation should not fail"); @@ -152,6 +153,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { }); } +#[allow(dead_code)] fn criterion_benchmark(c: &mut Criterion) { bench("sha256", 16, c); // bench("sha256", 20, c); diff --git a/examples/sha256/table16.rs b/examples/sha256/table16.rs index 2dd7a42..3d1c078 100644 --- a/examples/sha256/table16.rs +++ b/examples/sha256/table16.rs @@ -167,7 +167,7 @@ impl Table16Chip { ); let message_schedule = - MessageSchedule::configure(meta, lookup_inputs, message_schedule, extras, perm.clone()); + MessageSchedule::configure(meta, lookup_inputs, message_schedule, extras, perm); Table16Config { lookup_table, @@ -240,6 +240,8 @@ impl Sha256Instructions for Table16Chip { /// Common assignment patterns used by Table16 regions. trait Table16Assignment { // Assign cells for general spread computation used in sigma, ch, ch_neg, maj gates + #[allow(clippy::too_many_arguments)] + #[allow(clippy::type_complexity)] fn assign_spread_outputs( &self, region: &mut Region<'_, Table16Chip>, @@ -280,6 +282,7 @@ trait Table16Assignment { } // Assign outputs of sigma gates + #[allow(clippy::too_many_arguments)] fn assign_sigma_outputs( &self, region: &mut Region<'_, Table16Chip>, diff --git a/examples/sha256/table16/compression.rs b/examples/sha256/table16/compression.rs index 846e774..7a70fe5 100644 --- a/examples/sha256/table16/compression.rs +++ b/examples/sha256/table16/compression.rs @@ -180,6 +180,8 @@ pub struct State { } impl State { + #[allow(clippy::many_single_char_names)] + #[allow(clippy::too_many_arguments)] pub fn new( a: StateWord, b: StateWord, @@ -749,6 +751,7 @@ impl Compression { Ok(digest) } + #[cfg(test)] pub(super) fn empty_configure( meta: &mut ConstraintSystem, lookup: SpreadInputs, diff --git a/examples/sha256/table16/compression/compression_gates.rs b/examples/sha256/table16/compression/compression_gates.rs index 5004412..687d985 100644 --- a/examples/sha256/table16/compression/compression_gates.rs +++ b/examples/sha256/table16/compression/compression_gates.rs @@ -10,6 +10,7 @@ impl CompressionGate { // Decompose `A,B,C,D` words // (2, 11, 9, 10)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_decompose_abcd( s_decompose_abcd: Expression, a: Expression, @@ -67,6 +68,7 @@ impl CompressionGate { // Decompose `E,F,G,H` words // (6, 5, 14, 7)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_decompose_efgh( s_decompose_efgh: Expression, a_lo: Expression, @@ -124,6 +126,7 @@ impl CompressionGate { // s_upper_sigma_0 on abcd words // (2, 11, 9, 10)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_upper_sigma_0( s_upper_sigma_0: Expression, spread_r0_even: Expression, @@ -165,6 +168,7 @@ impl CompressionGate { // s_upper_sigma_1 on efgh words // (6, 5, 14, 7)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_upper_sigma_1( s_upper_sigma_1: Expression, spread_r0_even: Expression, @@ -206,6 +210,7 @@ impl CompressionGate { } // First part of choice gate on (E, F, G), E ∧ F + #[allow(clippy::too_many_arguments)] pub fn s_ch( s_ch: Expression, spread_p0_even: Expression, @@ -229,6 +234,7 @@ impl CompressionGate { } // Second part of Choice gate on (E, F, G), ¬E ∧ G + #[allow(clippy::too_many_arguments)] pub fn s_ch_neg( s_ch_neg: Expression, spread_q0_even: Expression, @@ -260,6 +266,7 @@ impl CompressionGate { } // Majority gate on (A, B, C) + #[allow(clippy::too_many_arguments)] pub fn s_maj( s_maj: Expression, spread_m_0_even: Expression, @@ -302,6 +309,7 @@ impl CompressionGate { } // s_h_prime to get H' = H + Ch(E, F, G) + s_upper_sigma_1(E) + K + W + #[allow(clippy::too_many_arguments)] pub fn s_h_prime( s_h_prime: Expression, h_prime_lo: Expression, @@ -335,6 +343,7 @@ impl CompressionGate { } // s_a_new to get A_new = H' + Maj(A, B, C) + s_upper_sigma_0(A) + #[allow(clippy::too_many_arguments)] pub fn s_a_new( s_a_new: Expression, a_new_lo: Expression, @@ -359,6 +368,7 @@ impl CompressionGate { } // s_e_new to get E_new = H' + D + #[allow(clippy::too_many_arguments)] pub fn s_e_new( s_e_new: Expression, e_new_lo: Expression, @@ -385,6 +395,7 @@ impl CompressionGate { } // s_digest on final round + #[allow(clippy::too_many_arguments)] pub fn s_digest( s_digest: Expression, lo_0: Expression, diff --git a/examples/sha256/table16/compression/compression_util.rs b/examples/sha256/table16/compression/compression_util.rs index 3052a15..3191115 100644 --- a/examples/sha256/table16/compression/compression_util.rs +++ b/examples/sha256/table16/compression/compression_util.rs @@ -12,6 +12,7 @@ use halo2::{ }; // Test vector 'abc' +#[cfg(test)] pub const COMPRESSION_OUTPUT: [u32; 8] = [ 0b10111010011110000001011010111111, 0b10001111000000011100111111101010, @@ -767,6 +768,7 @@ impl Compression { } // s_h_prime to get H' = H + Ch(E, F, G) + s_upper_sigma_1(E) + K + W + #[allow(clippy::too_many_arguments)] pub(super) fn assign_h_prime( &self, region: &mut Region<'_, Table16Chip>, @@ -1051,6 +1053,7 @@ impl Compression { } // Assign hi and lo halves for both dense and spread versions of a word + #[allow(clippy::type_complexity)] pub fn assign_word_halves( &self, region: &mut Region<'_, Table16Chip>, @@ -1081,6 +1084,7 @@ pub fn val_from_dense_halves(dense_halves: (CellValue16, CellValue16)) -> u32 { dense_halves.0.value.unwrap() as u32 + (1 << 16) * dense_halves.1.value.unwrap() as u32 } +#[allow(clippy::many_single_char_names)] pub fn match_state( state: State, ) -> ( diff --git a/examples/sha256/table16/compression/subregion_digest.rs b/examples/sha256/table16/compression/subregion_digest.rs index 18948c4..dd077cf 100644 --- a/examples/sha256/table16/compression/subregion_digest.rs +++ b/examples/sha256/table16/compression/subregion_digest.rs @@ -7,6 +7,7 @@ use halo2::{ }; impl Compression { + #[allow(clippy::many_single_char_names)] pub fn assign_digest( &self, region: &mut Region<'_, Table16Chip>, diff --git a/examples/sha256/table16/compression/subregion_initial.rs b/examples/sha256/table16/compression/subregion_initial.rs index ba5a84f..ea1dd3c 100644 --- a/examples/sha256/table16/compression/subregion_initial.rs +++ b/examples/sha256/table16/compression/subregion_initial.rs @@ -3,6 +3,7 @@ use super::{compression_util::*, Compression, State}; use halo2::{arithmetic::FieldExt, circuit::Region, plonk::Error}; impl Compression { + #[allow(clippy::many_single_char_names)] pub fn initialize_iv( &self, region: &mut Region<'_, Table16Chip>, @@ -48,6 +49,7 @@ impl Compression { )) } + #[allow(clippy::many_single_char_names)] pub fn initialize_state( &self, region: &mut Region<'_, Table16Chip>, diff --git a/examples/sha256/table16/compression/subregion_main.rs b/examples/sha256/table16/compression/subregion_main.rs index 058550e..f2a2045 100644 --- a/examples/sha256/table16/compression/subregion_main.rs +++ b/examples/sha256/table16/compression/subregion_main.rs @@ -5,6 +5,7 @@ use super::{compression_util::*, Compression, State}; use halo2::{arithmetic::FieldExt, circuit::Region, plonk::Error}; impl Compression { + #[allow(clippy::many_single_char_names)] pub fn assign_round( &self, region: &mut Region<'_, Table16Chip>, diff --git a/examples/sha256/table16/message_schedule.rs b/examples/sha256/table16/message_schedule.rs index 3d72fd7..a34b9a6 100644 --- a/examples/sha256/table16/message_schedule.rs +++ b/examples/sha256/table16/message_schedule.rs @@ -17,9 +17,11 @@ mod subregion2; mod subregion3; use schedule_gates::ScheduleGate; -pub use schedule_util::get_msg_schedule_test_input; use schedule_util::*; +#[cfg(test)] +pub use schedule_util::get_msg_schedule_test_input; + #[derive(Clone, Debug)] pub(super) struct MessageWord { var: Cell, @@ -65,6 +67,7 @@ impl MessageSchedule { /// `extras` contains columns that the message schedule will only use for internal /// gates, and will not place any constraints on (such as lookup constraints) outside /// itself. + #[allow(clippy::many_single_char_names)] pub(super) fn configure( meta: &mut ConstraintSystem, lookup: SpreadInputs, @@ -303,6 +306,7 @@ impl MessageSchedule { } } + #[allow(clippy::type_complexity)] pub(super) fn process( &self, layouter: &mut impl Layouter>, @@ -399,12 +403,12 @@ impl MessageSchedule { } // Assign W[0..16] - for i in 0..16 { + for (i, word) in input.iter().enumerate() { let (var, halves) = - self.assign_word_and_halves(&mut region, input[i].value.unwrap(), i)?; + self.assign_word_and_halves(&mut region, word.value.unwrap(), i)?; w.push(MessageWord { var, - value: input[i].value, + value: word.value, }); w_halves.push(halves); } @@ -437,6 +441,7 @@ impl MessageSchedule { } /// Empty configuration without gates. Useful for fast testing + #[cfg(test)] pub(super) fn empty_configure( meta: &mut ConstraintSystem, lookup: SpreadInputs, diff --git a/examples/sha256/table16/message_schedule/schedule_gates.rs b/examples/sha256/table16/message_schedule/schedule_gates.rs index 3d4d46f..1fabd37 100644 --- a/examples/sha256/table16/message_schedule/schedule_gates.rs +++ b/examples/sha256/table16/message_schedule/schedule_gates.rs @@ -5,6 +5,7 @@ pub struct ScheduleGate(pub Expression); impl ScheduleGate { /// s_word for W_16 to W_63 + #[allow(clippy::too_many_arguments)] pub fn s_word( s_word: Expression, sigma_0_lo: Expression, @@ -42,6 +43,7 @@ impl ScheduleGate { /// s_decompose_1 for W_1 to W_13 /// (3, 4, 11, 14)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_decompose_1( s_decompose_1: Expression, a: Expression, @@ -64,6 +66,8 @@ impl ScheduleGate { /// s_decompose_2 for W_14 to W_48 /// (3, 4, 3, 7, 1, 1, 13)-bit chunks + #[allow(clippy::many_single_char_names)] + #[allow(clippy::too_many_arguments)] pub fn s_decompose_2( s_decompose_2: Expression, a: Expression, @@ -92,6 +96,7 @@ impl ScheduleGate { /// s_decompose_3 for W_49 to W_61 /// (10, 7, 2, 13)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_decompose_3( s_decompose_3: Expression, a: Expression, @@ -132,6 +137,7 @@ impl ScheduleGate { /// sigma_0 v1 on W_1 to W_13 /// (3, 4, 11, 14)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_lower_sigma_0( s_lower_sigma_0: Expression, spread_r0_even: Expression, @@ -180,6 +186,7 @@ impl ScheduleGate { /// sigma_1 v1 on W_49 to W_61 /// (10, 7, 2, 13)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_lower_sigma_1( s_lower_sigma_1: Expression, spread_r0_even: Expression, @@ -218,12 +225,12 @@ impl ScheduleGate { + spread_b_lo.clone() * F::from_u64(1 << 50) + spread_b_mid.clone() * F::from_u64(1 << 54) + spread_b_hi.clone() * F::from_u64(1 << 58); - let xor_2 = spread_d.clone() - + spread_a.clone() * F::from_u64(1 << 26) - + spread_b_lo.clone() * F::from_u64(1 << 46) - + spread_b_mid.clone() * F::from_u64(1 << 50) - + spread_b_hi.clone() * F::from_u64(1 << 54) - + spread_c.clone() * F::from_u64(1 << 60); + let xor_2 = spread_d + + spread_a * F::from_u64(1 << 26) + + spread_b_lo * F::from_u64(1 << 46) + + spread_b_mid * F::from_u64(1 << 50) + + spread_b_hi * F::from_u64(1 << 54) + + spread_c * F::from_u64(1 << 60); let xor = xor_0 + xor_1 + xor_2; ScheduleGate( @@ -234,6 +241,7 @@ impl ScheduleGate { /// sigma_0 v2 on W_14 to W_48 /// (3, 4, 3, 7, 1, 1, 13)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_lower_sigma_0_v2( s_lower_sigma_0_v2: Expression, spread_r0_even: Expression, @@ -296,6 +304,7 @@ impl ScheduleGate { /// sigma_1 v2 on W_14 to W_48 /// (3, 4, 3, 7, 1, 1, 13)-bit chunks + #[allow(clippy::too_many_arguments)] pub fn s_lower_sigma_1_v2( s_lower_sigma_1_v2: Expression, spread_r0_even: Expression, diff --git a/examples/sha256/table16/message_schedule/schedule_util.rs b/examples/sha256/table16/message_schedule/schedule_util.rs index add0859..daa4706 100644 --- a/examples/sha256/table16/message_schedule/schedule_util.rs +++ b/examples/sha256/table16/message_schedule/schedule_util.rs @@ -1,4 +1,4 @@ -use super::super::{super::BLOCK_SIZE, BlockWord, CellValue16, Table16Chip, ROUNDS}; +use super::super::{CellValue16, Table16Chip}; use super::MessageSchedule; use halo2::{ arithmetic::FieldExt, @@ -6,6 +6,9 @@ use halo2::{ plonk::Error, }; +#[cfg(test)] +use super::super::{super::BLOCK_SIZE, BlockWord, ROUNDS}; + // Rows needed for each gate pub const DECOMPOSE_0_ROWS: usize = 2; pub const DECOMPOSE_1_ROWS: usize = 2; @@ -36,11 +39,11 @@ pub fn get_word_row(word_idx: usize) -> usize { assert!(word_idx <= 63); if word_idx == 0 { 0 - } else if word_idx >= 1 && word_idx <= 13 { + } else if (1..=13).contains(&word_idx) { SUBREGION_0_ROWS + SUBREGION_1_WORD * (word_idx - 1) as usize - } else if word_idx >= 14 && word_idx <= 48 { - SUBREGION_0_ROWS + SUBREGION_1_ROWS + SUBREGION_2_WORD * (word_idx - 14) + 1 as usize - } else if word_idx >= 49 && word_idx <= 61 { + } else if (14..=48).contains(&word_idx) { + SUBREGION_0_ROWS + SUBREGION_1_ROWS + SUBREGION_2_WORD * (word_idx - 14) + 1 + } else if (49..=61).contains(&word_idx) { SUBREGION_0_ROWS + SUBREGION_1_ROWS + SUBREGION_2_ROWS @@ -55,6 +58,7 @@ pub fn get_word_row(word_idx: usize) -> usize { } /// Test vector: "abc" +#[cfg(test)] pub fn get_msg_schedule_test_input() -> [BlockWord; BLOCK_SIZE] { [ BlockWord::new(0b01100001011000100110001110000000), @@ -76,6 +80,7 @@ pub fn get_msg_schedule_test_input() -> [BlockWord; BLOCK_SIZE] { ] } +#[cfg(test)] pub const MSG_SCHEDULE_TEST_OUTPUT: [u32; ROUNDS] = [ 0b01100001011000100110001110000000, 0b00000000000000000000000000000000, diff --git a/examples/sha256/table16/message_schedule/subregion1.rs b/examples/sha256/table16/message_schedule/subregion1.rs index f8ab492..ab101a9 100644 --- a/examples/sha256/table16/message_schedule/subregion1.rs +++ b/examples/sha256/table16/message_schedule/subregion1.rs @@ -79,12 +79,12 @@ impl MessageSchedule { Ok(Subregion1Word { index, - a: CellValue32::new(a, pieces[0].into()), - b: CellValue32::new(b, pieces[1].into()), + a: CellValue32::new(a, pieces[0]), + b: CellValue32::new(b, pieces[1]), c: CellValue32::new(spread_c.dense.var, spread_c.dense.value.unwrap().into()), d: CellValue32::new(spread_d.dense.var, spread_d.dense.value.unwrap().into()), - spread_c: CellValue32::new(spread_c.spread.var, spread_c.spread.value.unwrap().into()), - spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap().into()), + spread_c: CellValue32::new(spread_c.spread.var, spread_c.spread.value.unwrap()), + spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap()), }) } diff --git a/examples/sha256/table16/message_schedule/subregion2.rs b/examples/sha256/table16/message_schedule/subregion2.rs index 3e6120e..3cec400 100644 --- a/examples/sha256/table16/message_schedule/subregion2.rs +++ b/examples/sha256/table16/message_schedule/subregion2.rs @@ -162,7 +162,7 @@ impl MessageSchedule { for i in 27..49 { tmp_lower_sigma_0_v2_results = - new_word(i, tmp_lower_sigma_0_v2_results[i + 2 - 15 - 14].clone())?; + new_word(i, tmp_lower_sigma_0_v2_results[i + 2 - 15 - 14])?; } // Return lower_sigma_0_v2 output for W_[36..49] @@ -209,18 +209,19 @@ impl MessageSchedule { Ok(Subregion2Word { index, - a: CellValue32::new(a, pieces[0].into()), + a: CellValue32::new(a, pieces[0]), b: CellValue32::new(spread_b.dense.var, spread_b.dense.value.unwrap().into()), - c: CellValue32::new(c, pieces[2].into()), + c: CellValue32::new(c, pieces[2]), d: CellValue32::new(spread_d.dense.var, spread_d.dense.value.unwrap().into()), - e: CellValue32::new(e, pieces[4].into()), - f: CellValue32::new(f, pieces[5].into()), + e: CellValue32::new(e, pieces[4]), + f: CellValue32::new(f, pieces[5]), g: CellValue32::new(spread_g.dense.var, spread_g.dense.value.unwrap().into()), - spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap().into()), - spread_g: CellValue32::new(spread_g.spread.var, spread_g.spread.value.unwrap().into()), + spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap()), + spread_g: CellValue32::new(spread_g.spread.var, spread_g.spread.value.unwrap()), }) } + #[allow(clippy::type_complexity)] fn assign_lower_sigma_v2_pieces( &self, region: &mut Region<'_, Table16Chip>, @@ -384,7 +385,7 @@ impl MessageSchedule { let row = get_word_row(subregion2_word.index) + SIGMA_0_V2_ROWS + 3; let (spread_a, spread_b_lo, spread_b_hi, spread_c, spread_d, e, f, spread_g) = - self.assign_lower_sigma_v2_pieces(region, row, subregion2_word.clone())?; + self.assign_lower_sigma_v2_pieces(region, row, subregion2_word)?; // (3, 4, 3, 7, 1, 1, 13) diff --git a/examples/sha256/table16/message_schedule/subregion3.rs b/examples/sha256/table16/message_schedule/subregion3.rs index 4fdff42..8cf3035 100644 --- a/examples/sha256/table16/message_schedule/subregion3.rs +++ b/examples/sha256/table16/message_schedule/subregion3.rs @@ -8,9 +8,11 @@ use halo2::{arithmetic::FieldExt, circuit::Region, plonk::Error}; // (10, 7, 2, 13)-bit chunks pub struct Subregion3Word { index: usize, + #[allow(dead_code)] a: CellValue32, b: CellValue32, c: CellValue32, + #[allow(dead_code)] d: CellValue32, spread_a: CellValue32, spread_d: CellValue32, @@ -177,11 +179,11 @@ impl MessageSchedule { Ok(Subregion3Word { index, a: CellValue32::new(spread_a.dense.var, spread_a.dense.value.unwrap().into()), - b: CellValue32::new(b, pieces[1].into()), - c: CellValue32::new(c, pieces[2].into()), + b: CellValue32::new(b, pieces[1]), + c: CellValue32::new(c, pieces[2]), d: CellValue32::new(spread_d.dense.var, spread_d.dense.value.unwrap().into()), - spread_a: CellValue32::new(spread_a.spread.var, spread_a.spread.value.unwrap().into()), - spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap().into()), + spread_a: CellValue32::new(spread_a.spread.var, spread_a.spread.value.unwrap()), + spread_d: CellValue32::new(spread_d.spread.var, spread_d.spread.value.unwrap()), }) } diff --git a/examples/sha256/table16/spread_table.rs b/examples/sha256/table16/spread_table.rs index ed2c6f5..df0f8a7 100644 --- a/examples/sha256/table16/spread_table.rs +++ b/examples/sha256/table16/spread_table.rs @@ -76,8 +76,8 @@ impl SpreadVar { }) } - pub(super) fn without_lookup<'r, C: Chip>( - region: &mut Region<'r, C>, + pub(super) fn without_lookup( + region: &mut Region<'_, C>, dense_col: Column, dense_row: usize, spread_col: Column, diff --git a/examples/sha256/table16/util.rs b/examples/sha256/table16/util.rs index 7052a8e..e6ae62e 100644 --- a/examples/sha256/table16/util.rs +++ b/examples/sha256/table16/util.rs @@ -48,14 +48,14 @@ pub fn compress_u32(word: u32) -> u16 { // Chops a 32-bit word into pieces of given length. The lengths are specified // starting from the little end. pub fn chop_u32(word: u32, lengths: &[u8]) -> Vec { - assert_eq!(lengths.iter().sum::(), 32 as u8); + assert_eq!(lengths.iter().sum::(), 32u8); let mut pieces: Vec = Vec::with_capacity(lengths.len()); for i in 0..lengths.len() { assert!(lengths[i] > 0); // lengths[i] bitstring of all 1's let mask: u32 = (1 << lengths[i]) as u32 - 1; // Shift mask by bits already shifted - let offset: u8 = lengths[0..i].into_iter().sum(); + let offset: u8 = lengths[0..i].iter().sum(); let mask: u32 = mask << offset; pieces.push((word & mask) >> offset as u32); } @@ -65,14 +65,14 @@ pub fn chop_u32(word: u32, lengths: &[u8]) -> Vec { // Chops a 64-bit word into pieces of given length. The lengths are specified // starting from the little end. pub fn chop_u64(word: u64, lengths: &[u8]) -> Vec { - assert_eq!(lengths.iter().sum::(), 64 as u8); + assert_eq!(lengths.iter().sum::(), 64u8); let mut pieces: Vec = Vec::with_capacity(lengths.len()); for i in 0..lengths.len() { assert!(lengths[i] > 0); // lengths[i] bitstring of all 1's - let mask: u64 = ((1 as u64) << lengths[i]) - 1; + let mask: u64 = (1u64 << lengths[i]) - 1; // Shift mask by bits already shifted - let offset: u8 = lengths[0..i].into_iter().sum(); + let offset: u8 = lengths[0..i].iter().sum(); let mask: u64 = mask << offset; pieces.push((word & mask) >> offset as u64); }