From 07e704c968db3803eb2aa4ead70e6214343b5f48 Mon Sep 17 00:00:00 2001 From: Tomusdrw Date: Tue, 23 Feb 2016 11:40:23 +0100 Subject: [PATCH] Fixing clippy warnings. Implementing PartialEq for Uints --- ethcore/src/block.rs | 10 +++++----- ethcore/src/ethereum/ethash.rs | 21 +++++++++------------ ethcore/src/evm/interpreter.rs | 7 ++++--- ethcore/src/lib.rs | 2 +- ethcore/src/transaction.rs | 12 +++++++----- hook.sh | 2 +- parity/main.rs | 10 ++++++---- util/src/keys/directory.rs | 2 +- util/src/nibbleslice.rs | 6 +++--- util/src/uint.rs | 29 ++++++++++++++++++++--------- 10 files changed, 57 insertions(+), 44 deletions(-) diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs index b7590143e..a1194c665 100644 --- a/ethcore/src/block.rs +++ b/ethcore/src/block.rs @@ -48,7 +48,7 @@ impl Block { if urlp.at(1).unwrap().iter().find(|i| i.as_val::().is_err()).is_some() { return false; } - + if !urlp.at(2).unwrap().is_list() { return false; } if urlp.at(2).unwrap().iter().find(|i| i.as_val::
().is_err()).is_some() { return false; @@ -61,7 +61,7 @@ impl Block { impl Decodable for Block { fn decode(decoder: &D) -> Result where D: Decoder { if decoder.as_raw().len() != try!(decoder.as_rlp().payload_info()).total() { - return Err(DecoderError::RlpIsTooBig); + return Err(DecoderError::RlpIsTooBig); } let d = decoder.as_rlp(); if d.item_count() != 3 { @@ -87,7 +87,7 @@ pub struct ExecutedBlock { state: State, } -/// A set of references to `ExecutedBlock` fields that are publicly accessible. +/// A set of references to `ExecutedBlock` fields that are publicly accessible. pub struct BlockRefMut<'a> { /// Block header. pub header: &'a Header, @@ -171,7 +171,7 @@ pub struct SealedBlock { impl<'x, 'y> OpenBlock<'x, 'y> { /// Create a new OpenBlock ready for transaction pushing. - pub fn new<'a, 'b>(engine: &'a Engine, db: JournalDB, parent: &Header, last_hashes: &'b LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a, 'b> { + pub fn new(engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: &'y LastHashes, author: Address, extra_data: Bytes) -> Self { let mut r = OpenBlock { block: ExecutedBlock::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce())), engine: engine, @@ -284,7 +284,7 @@ impl<'x, 'y> IsBlock for ClosedBlock<'x, 'y> { } impl<'x, 'y> ClosedBlock<'x, 'y> { - fn new<'a, 'b>(open_block: OpenBlock<'a, 'b>, uncle_bytes: Bytes) -> ClosedBlock<'a, 'b> { + fn new(open_block: OpenBlock<'x, 'y>, uncle_bytes: Bytes) -> Self { ClosedBlock { open_block: open_block, uncle_bytes: uncle_bytes, diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs index ff6c6ba72..8c411e7f0 100644 --- a/ethcore/src/ethereum/ethash.rs +++ b/ethcore/src/ethereum/ethash.rs @@ -87,13 +87,10 @@ impl Engine for Ethash { fn schedule(&self, env_info: &EnvInfo) -> Schedule { trace!(target: "client", "Creating schedule. param={:?}, fCML={}", self.spec().engine_params.get("frontierCompatibilityModeLimit"), self.u64_param("frontierCompatibilityModeLimit")); - match env_info.number < self.u64_param("frontierCompatibilityModeLimit") { - true => { - Schedule::new_frontier() - }, - _ => { - Schedule::new_homestead() - }, + if env_info.number < self.u64_param("frontierCompatibilityModeLimit") { + Schedule::new_frontier() + } else { + Schedule::new_homestead() } } @@ -147,7 +144,7 @@ impl Engine for Ethash { } let difficulty = Ethash::boundary_to_difficulty(&Ethash::from_ethash(quick_get_difficulty( - &Ethash::to_ethash(header.bare_hash()), + &Ethash::to_ethash(header.bare_hash()), header.nonce().low_u64(), &Ethash::to_ethash(header.mix_hash())))); if difficulty < header.difficulty { @@ -189,7 +186,7 @@ impl Engine for Ethash { let min_gas = parent.gas_limit - parent.gas_limit / gas_limit_divisor; let max_gas = parent.gas_limit + parent.gas_limit / gas_limit_divisor; if header.gas_limit <= min_gas || header.gas_limit >= max_gas { - return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit }))); + return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit }))); } Ok(()) } @@ -220,8 +217,8 @@ impl Ethash { let frontier_limit = self.u64_param("frontierCompatibilityModeLimit"); let mut target = if header.number < frontier_limit { if header.timestamp >= parent.timestamp + duration_limit { - parent.difficulty - (parent.difficulty / difficulty_bound_divisor) - } + parent.difficulty - (parent.difficulty / difficulty_bound_divisor) + } else { parent.difficulty + (parent.difficulty / difficulty_bound_divisor) } @@ -243,7 +240,7 @@ impl Ethash { } target } - + fn boundary_to_difficulty(boundary: &H256) -> U256 { U256::from((U512::one() << 256) / x!(U256::from(boundary.as_slice()))) } diff --git a/ethcore/src/evm/interpreter.rs b/ethcore/src/evm/interpreter.rs index e09c37319..7491321cb 100644 --- a/ethcore/src/evm/interpreter.rs +++ b/ethcore/src/evm/interpreter.rs @@ -581,9 +581,10 @@ impl Interpreter { let code_address = stack.pop_back(); let code_address = u256_to_address(&code_address); - let value = match instruction == instructions::DELEGATECALL { - true => None, - false => Some(stack.pop_back()) + let value = if instruction == instructions::DELEGATECALL { + None + } else { + Some(stack.pop_back()) }; let in_off = stack.pop_back(); diff --git a/ethcore/src/lib.rs b/ethcore/src/lib.rs index 9deb3a691..3d43fd725 100644 --- a/ethcore/src/lib.rs +++ b/ethcore/src/lib.rs @@ -22,7 +22,7 @@ // TODO [todr] not really sure #![cfg_attr(feature="dev", allow(needless_range_loop))] // Shorter than if-else -#![cfg_attr(feautre="dev", allow(match_bool))] +#![cfg_attr(feature="dev", allow(match_bool))] // Keeps consistency (all lines with `.clone()`) and helpful when changing ref to non-ref. #![cfg_attr(feature="dev", allow(clone_on_copy))] diff --git a/ethcore/src/transaction.rs b/ethcore/src/transaction.rs index b43c271d3..fc9886a4d 100644 --- a/ethcore/src/transaction.rs +++ b/ethcore/src/transaction.rs @@ -37,10 +37,11 @@ impl Default for Action { impl Decodable for Action { fn decode(decoder: &D) -> Result where D: Decoder { let rlp = decoder.as_rlp(); - match rlp.is_empty() { - true => Ok(Action::Create), - false => Ok(Action::Call(try!(rlp.as_val()))) - } + if rlp.is_empty() { + Ok(Action::Create) + } else { + Ok(Action::Call(try!(rlp.as_val()))) + } } } @@ -79,6 +80,7 @@ impl Transaction { } impl FromJson for SignedTransaction { + #[cfg_attr(feature="dev", allow(single_char_pattern))] fn from_json(json: &Json) -> SignedTransaction { let t = Transaction { nonce: xjson!(&json["nonce"]), @@ -110,7 +112,7 @@ impl FromJson for SignedTransaction { impl Transaction { /// The message hash of the transaction. - pub fn hash(&self) -> H256 { + pub fn hash(&self) -> H256 { let mut stream = RlpStream::new(); self.rlp_append_unsigned_transaction(&mut stream); stream.out().sha3() diff --git a/hook.sh b/hook.sh index bb17f4e4f..106ffe4f0 100755 --- a/hook.sh +++ b/hook.sh @@ -1,3 +1,3 @@ #!/bin/sh -echo "#!/bin/sh\ncargo test -p ethcore" >> ./.git/hooks/pre-push +echo "#!/bin/sh\ncargo test -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity --features dev" > ./.git/hooks/pre-push chmod +x ./.git/hooks/pre-push diff --git a/parity/main.rs b/parity/main.rs index 328bfc0e2..e25933f2d 100644 --- a/parity/main.rs +++ b/parity/main.rs @@ -181,7 +181,7 @@ impl Configuration { } fn _keys_path(&self) -> String { - self.args.flag_keys_path.replace("$HOME", env::home_dir().unwrap().to_str().unwrap()) + self.args.flag_keys_path.replace("$HOME", env::home_dir().unwrap().to_str().unwrap()) } fn spec(&self) -> Spec { @@ -194,9 +194,10 @@ impl Configuration { } fn normalize_enode(e: &str) -> Option { - match is_valid_node_url(e) { - true => Some(e.to_owned()), - false => None, + if is_valid_node_url(e) { + Some(e.to_owned()) + } else { + None } } @@ -209,6 +210,7 @@ impl Configuration { } } + #[cfg_attr(feature="dev", allow(useless_format))] fn net_addresses(&self) -> (Option, Option) { let mut listen_address = None; let mut public_address = None; diff --git a/util/src/keys/directory.rs b/util/src/keys/directory.rs index bc875db3f..d7db8ac11 100644 --- a/util/src/keys/directory.rs +++ b/util/src/keys/directory.rs @@ -305,7 +305,7 @@ fn uuid_to_string(uuid: &Uuid) -> String { } fn uuid_from_string(s: &str) -> Result { - let parts: Vec<&str> = s.split("-").collect(); + let parts: Vec<&str> = s.split('-').collect(); if parts.len() != 5 { return Err(UtilError::BadSize); } let mut uuid = H128::zero(); diff --git a/util/src/nibbleslice.rs b/util/src/nibbleslice.rs index 047990368..e10def40a 100644 --- a/util/src/nibbleslice.rs +++ b/util/src/nibbleslice.rs @@ -69,13 +69,13 @@ impl<'a> Iterator for NibbleSliceIterator<'a> { impl<'a, 'view> NibbleSlice<'a> where 'a: 'view { /// Create a new nibble slice with the given byte-slice. - pub fn new(data: &[u8]) -> NibbleSlice { NibbleSlice::new_offset(data, 0) } + pub fn new(data: &'a [u8]) -> Self { NibbleSlice::new_offset(data, 0) } /// Create a new nibble slice with the given byte-slice with a nibble offset. - pub fn new_offset(data: &'a [u8], offset: usize) -> NibbleSlice { NibbleSlice{data: data, offset: offset, data_encode_suffix: &b""[..], offset_encode_suffix: 0} } + pub fn new_offset(data: &'a [u8], offset: usize) -> Self { NibbleSlice{data: data, offset: offset, data_encode_suffix: &b""[..], offset_encode_suffix: 0} } /// Create a composed nibble slice; one followed by the other. - pub fn new_composed(a: &'a NibbleSlice, b: &'a NibbleSlice) -> NibbleSlice<'a> { NibbleSlice{data: a.data, offset: a.offset, data_encode_suffix: b.data, offset_encode_suffix: b.offset} } + pub fn new_composed(a: &'a NibbleSlice, b: &'a NibbleSlice) -> Self { NibbleSlice{data: a.data, offset: a.offset, data_encode_suffix: b.data, offset_encode_suffix: b.offset} } /*pub fn new_composed_bytes_offset(a: &NibbleSlice, b: &NibbleSlice) -> (Bytes, usize) { let r: Vec::with_capacity((a.len() + b.len() + 1) / 2); diff --git a/util/src/uint.rs b/util/src/uint.rs index 7206a521e..906bd91d0 100644 --- a/util/src/uint.rs +++ b/util/src/uint.rs @@ -31,7 +31,7 @@ // //! Big unsigned integer types -//! +//! //! Implementation of a various large-but-fixed sized unsigned integer types. //! The functions here are designed to be fast. //! @@ -99,7 +99,7 @@ pub trait Uint: Sized + Default + FromStr + From + FromJson + fmt::Debug + /// Conversion to u64 with overflow checking fn as_u64(&self) -> u64; - + /// Return the least number of bits needed to represent the number fn bits(&self) -> usize; /// Return if specific bit is set @@ -124,7 +124,7 @@ pub trait Uint: Sized + Default + FromStr + From + FromJson + fmt::Debug + /// Multiple this `Uint` with other returning result and possible overflow fn overflowing_mul(self, other: Self) -> (Self, bool); - + /// Divide this `Uint` by other returning result and possible overflow fn overflowing_div(self, other: Self) -> (Self, bool); @@ -133,7 +133,7 @@ pub trait Uint: Sized + Default + FromStr + From + FromJson + fmt::Debug + /// Returns negation of this `Uint` and overflow (always true) fn overflowing_neg(self) -> (Self, bool); - + /// Shifts this `Uint` and returns overflow fn overflowing_shl(self, shift: u32) -> (Self, bool); } @@ -141,7 +141,7 @@ pub trait Uint: Sized + Default + FromStr + From + FromJson + fmt::Debug + macro_rules! construct_uint { ($name:ident, $n_words:expr) => ( /// Little-endian large integer type - #[derive(Copy, Clone, Eq, PartialEq)] + #[derive(Copy, Clone, Eq)] pub struct $name(pub [u64; $n_words]); impl Uint for $name { @@ -175,7 +175,7 @@ macro_rules! construct_uint { fn as_u32(&self) -> u32 { let &$name(ref arr) = self; if (arr[0] & (0xffffffffu64 << 32)) != 0 { - panic!("Integer overflow when casting U256") + panic!("Integer overflow when casting U256") } self.as_u64() as u32 } @@ -186,7 +186,7 @@ macro_rules! construct_uint { let &$name(ref arr) = self; for i in 1..$n_words { if arr[i] != 0 { - panic!("Integer overflow when casting U256") + panic!("Integer overflow when casting U256") } } arr[0] @@ -320,7 +320,7 @@ macro_rules! construct_uint { if b_carry { let ret = overflowing!($name(ret).overflowing_add($name(carry)), overflow); (ret, overflow) - } else { + } else { ($name(ret), overflow) } } @@ -448,7 +448,7 @@ macro_rules! construct_uint { } impl serde::Serialize for $name { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: serde::Serializer { let mut hex = "0x".to_owned(); let mut bytes = [0u8; 8 * $n_words]; @@ -791,6 +791,17 @@ macro_rules! construct_uint { } } + impl PartialEq for $name { + fn eq(&self, other: &$name) -> bool { + let &$name(ref me) = self; + let &$name(ref you) = other; + for i in 0..$n_words { + if me[$n_words - 1 - i] != you[$n_words - 1 - i] { return false; } + } + true + } + } + impl Hash for $name { fn hash(&self, state: &mut H) where H: Hasher { unsafe { state.write(::std::slice::from_raw_parts(self.0.as_ptr() as *mut u8, self.0.len() * 8)); }