Upgrade clippy and fmt

This patch
1. removes redundant closures
2. removes an unreachable pattern
3. renames clippy::cognitive_complexity to clippy::cyclomatic_complexity
4. allows deprecated item(std::error::Error::cause)
    * Allow it until error-chain and quick-error macros are fixed.
5. removes a redundant import
6. makes clippy skip false alarms

Author: Seulgi Kim

.travis.yml

@@ -58,17 +58,17 @@ jobs:
         - SKIP=`.travis/check-change '^test/'` && if [[ "$SKIP" = "noskip" ]]; then CHECK_RUST=1; fi
       install:
         - if [[ $CHECK_RUST ]]; then
-            rustup toolchain install nightly-2018-12-06 || exit 1;
-            rustup component add rustfmt-preview --toolchain nightly-2018-12-06 || exit 1;
-            rustup component add clippy-preview --toolchain nightly-2018-12-06 || exit 1;
+            rustup toolchain install nightly-2019-04-11 || exit 1;
+            rustup component add rustfmt-preview --toolchain nightly-2019-04-11 || exit 1;
+            rustup component add clippy-preview --toolchain nightly-2019-04-11 || exit 1;
           fi
         - nvm install 10
         - nvm use 10
         - npm install -g yarn
       script:
         - if [[ $CHECK_RUST ]]; then
-            cargo +nightly-2018-12-06 fmt -- --check || FAILED=1;
-            cargo +nightly-2018-12-06 clippy --all --all-targets -- -D warnings || FAILED=1;
+            cargo +nightly-2019-04-11 fmt -- --check || FAILED=1;
+            cargo +nightly-2019-04-11 clippy --all --all-targets -- -D warnings || FAILED=1;
           fi; test ! $FAILED
         - cd test && yarn && yarn lint
     - stage: deploy

codechain/config/mod.rs

@@ -58,7 +58,7 @@ impl Config {
 
     pub fn miner_options(&self) -> Result<MinerOptions, String> {
         let (reseal_on_own_transaction, reseal_on_external_transaction) =
-            match self.mining.reseal_on_txs.as_ref().map(|s| s.as_str()) {
+            match self.mining.reseal_on_txs.as_ref().map(String::as_str) {
                 Some("all") => (true, true),
                 Some("own") => (true, false),
                 Some("ext") => (false, true),

codechain/run_node.rs

@@ -25,7 +25,7 @@ use ccore::{
     Miner, MinerService, Scheme, Stratum, StratumConfig, StratumError, NUM_COLUMNS,
 };
 use cdiscovery::{Config, Discovery};
-use ckey::{Address, NetworkId};
+use ckey::{Address, NetworkId, PlatformAddress};
 use ckeystore::accounts_dir::RootDiskDirectory;
 use ckeystore::KeyStore;
 use clap::ArgMatches;
@@ -81,7 +81,7 @@ fn discovery_start(
         bucket_size: cfg.discovery_bucket_size.unwrap(),
         t_refresh: cfg.discovery_refresh.unwrap(),
     };
-    let use_kademlia = match cfg.discovery_type.as_ref().map(|s| s.as_str()) {
+    let use_kademlia = match cfg.discovery_type.as_ref().map(String::as_str) {
         Some("unstructured") => false,
         Some("kademlia") => true,
         Some(discovery_type) => return Err(format!("Unknown discovery {}", discovery_type)),
@@ -154,7 +154,7 @@ fn new_miner(
                 }
             },
             EngineType::Solo => miner
-                .set_author(config.mining.author.map_or(Address::default(), |a| a.into_address()))
+                .set_author(config.mining.author.map_or(Address::default(), PlatformAddress::into_address))
                 .expect("set_author never fails when Solo is used"),
         }
     }
@@ -203,7 +203,7 @@ fn unlock_accounts(ap: &AccountProvider, pf: &PasswordFile) -> Result<(), String
 }
 
 pub fn open_db(cfg: &config::Operating, client_config: &ClientConfig) -> Result<Arc<KeyValueDB>, String> {
-    let db_path = cfg.db_path.as_ref().map(|s| s.as_str()).unwrap();
+    let db_path = cfg.db_path.as_ref().map(String::as_str).unwrap();
     let client_path = Path::new(db_path);
     let mut db_config = DatabaseConfig::with_columns(NUM_COLUMNS);
 

core/src/block.rs

@@ -244,7 +244,7 @@ impl<'x> OpenBlock<'x> {
         })?;
         self.block.header.set_transactions_root(skewed_merkle_root(
             parent_transactions_root,
-            self.block.transactions.iter().map(|e| e.rlp_bytes()),
+            self.block.transactions.iter().map(Encodable::rlp_bytes),
         ));
         self.block.header.set_state_root(state_root);
 

core/src/blockchain/blockchain.rs

@@ -391,6 +391,8 @@ impl BlockChain {
     #[allow(dead_code)]
     pub fn epoch_transition_for(&self, parent_hash: H256) -> Option<EpochTransition> {
         // slow path: loop back block by block
+        #[allow(clippy::identity_conversion)]
+        // This is a false alarm. https://github.com/rust-lang/rust-clippy/issues/3944
         for hash in self.ancestry_iter(parent_hash)? {
             let details = self.block_details(&hash)?;
 

core/src/client/client.rs

@@ -199,7 +199,7 @@ impl Client {
         self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
         let transactions: Vec<UnverifiedTransaction> =
             transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect();
-        let hashes: Vec<_> = transactions.iter().map(|tx| tx.hash()).collect();
+        let hashes: Vec<_> = transactions.iter().map(UnverifiedTransaction::hash).collect();
         self.notify(|notify| {
             notify.transactions_received(hashes.clone(), peer_id);
         });

core/src/consensus/tendermint/worker.rs

@@ -417,7 +417,7 @@ impl Worker {
 
         proposal.and_then(|proposal| {
             let block_hash = proposal.on.block_hash.expect("Proposal message always include block hash");
-            let bytes = self.client().block(&BlockId::Hash(block_hash)).map(|block| block.into_inner());
+            let bytes = self.client().block(&BlockId::Hash(block_hash)).map(encoded::Block::into_inner);
             bytes.map(|bytes| (proposal.signature, proposal.signer_index, bytes))
         })
     }
@@ -1093,6 +1093,8 @@ impl Worker {
         let precommit_hash = message_hash(step, *header.parent_hash());
         let mut counter = 0;
 
+        #[allow(clippy::identity_conversion)]
+        // This is a false alarm. https://github.com/rust-lang/rust-clippy/issues/3944
         for (bitset_index, signature) in seal_view.signatures()? {
             let public = self.validators.get(header.parent_hash(), bitset_index);
             if !verify_schnorr(&public, &signature, &precommit_hash)? {

core/src/miner/miner.rs

@@ -31,7 +31,7 @@ use kvdb::KeyValueDB;
 use parking_lot::{Mutex, RwLock};
 use primitives::{Bytes, H256};
 
-use super::mem_pool::MemPool;
+use super::mem_pool::{Error as MemPoolError, MemPool};
 use super::mem_pool_types::{AccountDetails, MemPoolInput, TxOrigin, TxTimelock};
 use super::sealing_queue::SealingQueue;
 use super::work_notify::{NotifyWork, WorkPoster};
@@ -203,7 +203,7 @@ impl Miner {
 
     /// Get `Some` `clone()` of the current pending block or `None` if we're not sealing.
     pub fn pending_block(&self, latest_block_number: BlockNumber) -> Option<Block> {
-        self.map_pending_block(|b| b.to_base(), latest_block_number)
+        self.map_pending_block(IsBlock::to_base, latest_block_number)
     }
 
     /// Get `Some` `clone()` of the current pending block header or `None` if we're not sealing.
@@ -328,7 +328,7 @@ impl Miner {
                 Err(e) => Err(e),
                 Ok(()) => {
                     let idx = insertion_results_index;
-                    let result = insertion_results[idx].clone().map_err(|x| x.into_core_error())?;
+                    let result = insertion_results[idx].clone().map_err(MemPoolError::into_core_error)?;
                     inserted.push(tx_hashes[idx]);
                     insertion_results_index += 1;
                     Ok(result)

crypto/src/error.rs

@@ -14,9 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use rcrypto;
-use ring;
-
 quick_error! {
     #[derive(Debug)]
     pub enum Error {
@@ -48,32 +45,39 @@ quick_error! {
     }
 }
 
-quick_error! {
-    #[derive(Debug)]
-    pub enum SymmError wraps PrivSymmErr {
-        RustCrypto(e: rcrypto::symmetriccipher::SymmetricCipherError) {
-            display("symmetric crypto error")
-            from()
-        }
-        Ring(e: ring::error::Unspecified) {
-            display("symmetric crypto error")
-            cause(e)
-            from()
-        }
-        Offset(x: usize) {
-            display("offset {} greater than slice length", x)
+#[allow(deprecated)]
+mod errors {
+    use rcrypto;
+    use ring;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum SymmError wraps PrivSymmErr {
+            RustCrypto(e: rcrypto::symmetriccipher::SymmetricCipherError) {
+                display("symmetric crypto error")
+                    from()
+            }
+            Ring(e: ring::error::Unspecified) {
+                display("symmetric crypto error")
+                    cause(e)
+                    from()
+            }
+            Offset(x: usize) {
+                display("offset {} greater than slice length", x)
+            }
         }
     }
-}
 
-impl From<ring::error::Unspecified> for SymmError {
-    fn from(e: ring::error::Unspecified) -> SymmError {
-        SymmError(PrivSymmErr::Ring(e))
+    impl From<ring::error::Unspecified> for SymmError {
+        fn from(e: ring::error::Unspecified) -> SymmError {
+            SymmError(PrivSymmErr::Ring(e))
+        }
     }
-}
 
-impl From<rcrypto::symmetriccipher::SymmetricCipherError> for SymmError {
-    fn from(e: rcrypto::symmetriccipher::SymmetricCipherError) -> SymmError {
-        SymmError(PrivSymmErr::RustCrypto(e))
+    impl From<rcrypto::symmetriccipher::SymmetricCipherError> for SymmError {
+        fn from(e: rcrypto::symmetriccipher::SymmetricCipherError) -> SymmError {
+            SymmError(PrivSymmErr::RustCrypto(e))
+        }
     }
 }
+pub use self::errors::SymmError;

discovery/src/extension.rs

@@ -104,7 +104,7 @@ impl NetworkExtension<Never> for Extension {
 
                     addresses
                         .into_iter()
-                        .map(|kademlia_id| kademlia_id.into())
+                        .map(From::from)
                         .take(::std::cmp::min(self.config.bucket_size, len) as usize)
                         .collect()
                 } else {