Merge rust-bitcoin/rust-bitcoin#1040: Introduce rustfmt in a non-invasive manner

ee9a3ec Enable formatter for "src" (Tobin C. Harding)
743b197 Add use for Unexpected (Tobin C. Harding)
fd217e7 Use f instead of formatter (Tobin C. Harding)
7b50a96 Do not format prelude module (Tobin C. Harding)
01471f7 Shield hash_newtypes from rustfmt (Tobin C. Harding)
65d19d9 Refactor compile_error message (Tobin C. Harding)
6461e2d Run formatter on examples/ (Tobin C. Harding)
fd1c658 Add a rustfmt configuration file with explicit ignores (Tobin C. Harding)

Pull request description:

  Looks like we are getting to a place that rustfmt _might_ be able to be used. In an effort to introduce `rustfmt` without requiring devs to do excessively mundane reviews introduce `rustfmt` in a non-invasive manner. What this means is

  - Add a fully fleshed out `rustfmt` config file that explicitly ignores all the source files
  - Enable sections of code one by one so review is easier (including preparatory patches before doing each section).

  This PR currently does `examples` and all the source files at the root level of the crate (i.e. excludes all directories in `src/`). The other directories can then be done one at a time.

  Please see discussion on: rust-bitcoin/rust-bitcoin#959 for more context.

ACKs for top commit:
  sanket1729:
    ACK ee9a3ec
  apoelstra:
    ACK ee9a3ec

Tree-SHA512: f4ff3c031b5d685777e09bac2df59ed8217576b807da7699f44fe00aa509d0b7fe47617a8b3eff00d3125aeece3e010b8f9dd8733d315ccb2adc0e9a7d7f07e3

Author: ChallengeDev210

examples/bip32.rs

@@ -1,17 +1,14 @@
 extern crate bitcoin;
 
-use std::{env, process};
 use std::str::FromStr;
+use std::{env, process};
 
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::secp256k1::ffi::types::AlignedType;
 use bitcoin::secp256k1::Secp256k1;
-use bitcoin::PublicKey;
-use bitcoin::util::bip32::ExtendedPrivKey;
-use bitcoin::util::bip32::ExtendedPubKey;
-use bitcoin::util::bip32::DerivationPath;
-use bitcoin::util::bip32::ChildNumber;
 use bitcoin::util::address::Address;
-use bitcoin::secp256k1::ffi::types::AlignedType;
-use bitcoin::hashes::hex::FromHex;
+use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
+use bitcoin::PublicKey;
 
 fn main() {
     // This example derives root xprv from a 32-byte seed,
@@ -55,10 +52,7 @@ fn main() {
     // generate first receiving address at m/0/0
     // manually creating indexes this time
     let zero = ChildNumber::from_normal_idx(0).unwrap();
-    let public_key = xpub.derive_pub(&secp, &vec![zero, zero])
-                         .unwrap()
-                         .public_key;
+    let public_key = xpub.derive_pub(&secp, &vec![zero, zero]).unwrap().public_key;
     let address = Address::p2wpkh(&PublicKey::new(public_key), network).unwrap();
     println!("First receiving address: {}", address);
-
 }

examples/handshake.rs

@@ -1,9 +1,9 @@
 extern crate bitcoin;
 
+use std::io::{BufReader, Write};
 use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{env, process};
-use std::io::{Write, BufReader};
 
 use bitcoin::consensus::{encode, Decodable};
 use bitcoin::network::{address, constants, message, message_network};
@@ -80,10 +80,7 @@ fn build_version_message(address: SocketAddr) -> message::NetworkMessage {
     let services = constants::ServiceFlags::NONE;
 
     // "standard UNIX timestamp in seconds"
-    let timestamp = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("Time error")
-        .as_secs();
+    let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time error").as_secs();
 
     // "The network address of the node receiving this message"
     let addr_recv = address::Address::new(&address, constants::ServiceFlags::NONE);

rustfmt.toml

@@ -1 +1,85 @@
-disable_all_formatting = true
+# Eventually this shoud be: ignore = []
+ignore = [
+       "src/blockdata",
+       "src/consensus",
+       "src/network",
+       "src/util",
+]
+
+hard_tabs = false
+tab_spaces = 4
+newline_style = "Auto"
+indent_style = "Block"
+
+max_width = 100 # This is number of characters.
+# `use_small_heuristics` is ignored if the granular width config values are explicitly set.
+use_small_heuristics = "Max"    # "Max" == All granular width settings same as `max_width`.
+# # Granular width configuration settings. These are percentages of `max_width`.
+# fn_call_width = 60
+# attr_fn_like_width = 70
+# struct_lit_width = 18
+# struct_variant_width = 35
+# array_width = 60
+# chain_width = 60
+# single_line_if_else_max_width = 50
+
+wrap_comments = false
+format_code_in_doc_comments = false
+comment_width = 100             # Default 80
+normalize_comments = false
+normalize_doc_attributes = false
+format_strings = false
+format_macro_matchers = false
+format_macro_bodies = true
+hex_literal_case = "Preserve"
+empty_item_single_line = true
+struct_lit_single_line = true
+fn_single_line = true           # Default false
+where_single_line = false
+imports_indent = "Block"
+imports_layout = "Mixed"
+imports_granularity = "Module"     # Default "Preserve"
+group_imports = "StdExternalCrate" # Default "Preserve"
+reorder_imports = true
+reorder_modules = true
+reorder_impl_items = false
+type_punctuation_density = "Wide"
+space_before_colon = false
+space_after_colon = true
+spaces_around_ranges = false
+binop_separator = "Front"
+remove_nested_parens = true
+combine_control_expr = true
+overflow_delimited_expr = false
+struct_field_align_threshold = 0
+enum_discrim_align_threshold = 0
+match_arm_blocks = false        # Default true
+match_arm_leading_pipes = "Never"
+force_multiline_blocks = false
+fn_args_layout = "Tall"
+brace_style = "SameLineWhere"
+control_brace_style = "AlwaysSameLine"
+trailing_semicolon = true
+trailing_comma = "Vertical"
+match_block_trailing_comma = false
+blank_lines_upper_bound = 1
+blank_lines_lower_bound = 0
+edition = "2018"
+version = "One"
+inline_attribute_width = 0
+format_generated_files = true
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true
+condense_wildcard_suffixes = false
+color = "Auto"
+required_version = "1.5.1"
+unstable_features = false
+disable_all_formatting = false
+skip_children = false
+hide_parse_errors = false
+error_on_line_overflow = false
+error_on_unformatted = false
+emit_mode = "Files"
+make_backup = false

src/hash_types.rs

@@ -9,8 +9,7 @@
 //! hash).
 //!
 
-use bitcoin_hashes::{sha256, sha256d, hash160, hash_newtype};
-
+#[rustfmt::skip]
 macro_rules! impl_hashencode {
     ($hashtype:ident) => {
         impl $crate::consensus::Encodable for $hashtype {
@@ -25,43 +24,50 @@ macro_rules! impl_hashencode {
                 Ok(Self::from_inner(<<$hashtype as $crate::hashes::Hash>::Inner>::consensus_decode(r)?))
             }
         }
-    }
+    };
 }
 
-hash_newtype!(
-    Txid, sha256d::Hash, 32, doc="A bitcoin transaction hash/transaction ID.
+// newtypes module is solely here so we can rustfmt::skip.
+pub use newtypes::*;
+
+#[rustfmt::skip]
+mod newtypes {
+    use crate::hashes::{sha256, sha256d, hash160, hash_newtype};
+
+    hash_newtype!(
+        Txid, sha256d::Hash, 32, doc="A bitcoin transaction hash/transaction ID.
 
 For compatibility with the existing Bitcoin infrastructure and historical
 and current versions of the Bitcoin Core software itself, this and
 other [`sha256d::Hash`] types, are serialized in reverse
 byte order when converted to a hex string via [`std::fmt::Display`] trait operations.
 See [`hashes::Hash::DISPLAY_BACKWARD`] for more details.
 ");
-hash_newtype!(Wtxid, sha256d::Hash, 32, doc="A bitcoin witness transaction ID.");
-hash_newtype!(BlockHash, sha256d::Hash, 32, doc="A bitcoin block hash.");
-hash_newtype!(Sighash, sha256d::Hash, 32, doc="Hash of the transaction according to the signature algorithm");
+    hash_newtype!(Wtxid, sha256d::Hash, 32, doc="A bitcoin witness transaction ID.");
+    hash_newtype!(BlockHash, sha256d::Hash, 32, doc="A bitcoin block hash.");
+    hash_newtype!(Sighash, sha256d::Hash, 32, doc="Hash of the transaction according to the signature algorithm");
 
-hash_newtype!(PubkeyHash, hash160::Hash, 20, doc="A hash of a public key.");
-hash_newtype!(ScriptHash, hash160::Hash, 20, doc="A hash of Bitcoin Script bytecode.");
-hash_newtype!(WPubkeyHash, hash160::Hash, 20, doc="SegWit version of a public key hash.");
-hash_newtype!(WScriptHash, sha256::Hash, 32, doc="SegWit version of a Bitcoin Script bytecode hash.");
+    hash_newtype!(PubkeyHash, hash160::Hash, 20, doc="A hash of a public key.");
+    hash_newtype!(ScriptHash, hash160::Hash, 20, doc="A hash of Bitcoin Script bytecode.");
+    hash_newtype!(WPubkeyHash, hash160::Hash, 20, doc="SegWit version of a public key hash.");
+    hash_newtype!(WScriptHash, sha256::Hash, 32, doc="SegWit version of a Bitcoin Script bytecode hash.");
 
-hash_newtype!(TxMerkleNode, sha256d::Hash, 32, doc="A hash of the Merkle tree branch or root for transactions");
-hash_newtype!(WitnessMerkleNode, sha256d::Hash, 32, doc="A hash corresponding to the Merkle tree root for witness data");
-hash_newtype!(WitnessCommitment, sha256d::Hash, 32, doc="A hash corresponding to the witness structure commitment in the coinbase transaction");
-hash_newtype!(XpubIdentifier, hash160::Hash, 20, doc="XpubIdentifier as defined in BIP-32.");
+    hash_newtype!(TxMerkleNode, sha256d::Hash, 32, doc="A hash of the Merkle tree branch or root for transactions");
+    hash_newtype!(WitnessMerkleNode, sha256d::Hash, 32, doc="A hash corresponding to the Merkle tree root for witness data");
+    hash_newtype!(WitnessCommitment, sha256d::Hash, 32, doc="A hash corresponding to the witness structure commitment in the coinbase transaction");
+    hash_newtype!(XpubIdentifier, hash160::Hash, 20, doc="XpubIdentifier as defined in BIP-32.");
 
-hash_newtype!(FilterHash, sha256d::Hash, 32, doc="Filter hash, as defined in BIP-157");
-hash_newtype!(FilterHeader, sha256d::Hash, 32, doc="Filter header, as defined in BIP-157");
+    hash_newtype!(FilterHash, sha256d::Hash, 32, doc="Filter hash, as defined in BIP-157");
+    hash_newtype!(FilterHeader, sha256d::Hash, 32, doc="Filter header, as defined in BIP-157");
 
+    impl_hashencode!(Txid);
+    impl_hashencode!(Wtxid);
+    impl_hashencode!(BlockHash);
+    impl_hashencode!(Sighash);
 
-impl_hashencode!(Txid);
-impl_hashencode!(Wtxid);
-impl_hashencode!(BlockHash);
-impl_hashencode!(Sighash);
+    impl_hashencode!(TxMerkleNode);
+    impl_hashencode!(WitnessMerkleNode);
 
-impl_hashencode!(TxMerkleNode);
-impl_hashencode!(WitnessMerkleNode);
-
-impl_hashencode!(FilterHash);
-impl_hashencode!(FilterHeader);
+    impl_hashencode!(FilterHash);
+    impl_hashencode!(FilterHeader);
+}

src/internal_macros.rs

@@ -100,11 +100,9 @@ macro_rules! impl_array_newtype {
             type Output = <[$ty] as core::ops::Index<I>>::Output;
 
             #[inline]
-            fn index(&self, index: I) -> &Self::Output {
-                &self.0[index]
-            }
+            fn index(&self, index: I) -> &Self::Output { &self.0[index] }
         }
-    }
+    };
 }
 
 macro_rules! display_from_debug {
@@ -114,7 +112,7 @@ macro_rules! display_from_debug {
                 core::fmt::Debug::fmt(self, f)
             }
         }
-    }
+    };
 }
 
 #[cfg(test)]
@@ -142,8 +140,8 @@ macro_rules! serde_string_impl {
                 impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
                     type Value = $name;
 
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str($expecting)
+                    fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                        f.write_str($expecting)
                     }
 
                     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -190,8 +188,8 @@ macro_rules! serde_struct_human_string_impl {
                     impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
                         type Value = $name;
 
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str($expecting)
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str($expecting)
                         }
 
                         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -215,8 +213,8 @@ macro_rules! serde_struct_human_string_impl {
                     impl<'de> $crate::serde::de::Visitor<'de> for EnumVisitor {
                         type Value = Enum;
 
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str("a field name")
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str("a field name")
                         }
 
                         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -246,8 +244,8 @@ macro_rules! serde_struct_human_string_impl {
                     impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
                         type Value = $name;
 
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str("a struct")
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str("a struct")
                         }
 
                         fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
@@ -352,8 +350,7 @@ macro_rules! serde_struct_human_string_impl {
 /// - core::str::FromStr
 /// - hashes::hex::FromHex
 macro_rules! impl_bytes_newtype {
-    ($t:ident, $len:literal) => (
-
+    ($t:ident, $len:literal) => {
         impl core::fmt::LowerHex for $t {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                 for &ch in self.0.iter() {
@@ -378,9 +375,9 @@ macro_rules! impl_bytes_newtype {
         impl $crate::hashes::hex::FromHex for $t {
             fn from_byte_iter<I>(iter: I) -> Result<Self, $crate::hashes::hex::Error>
             where
-                I: core::iter::Iterator<Item=Result<u8, $crate::hashes::hex::Error>>
-                + core::iter::ExactSizeIterator
-                + core::iter::DoubleEndedIterator,
+                I: core::iter::Iterator<Item = Result<u8, $crate::hashes::hex::Error>>
+                    + core::iter::ExactSizeIterator
+                    + core::iter::DoubleEndedIterator,
             {
                 if iter.len() == $len {
                     let mut ret = [0; $len];
@@ -423,18 +420,20 @@ macro_rules! impl_bytes_newtype {
                     impl<'de> $crate::serde::de::Visitor<'de> for HexVisitor {
                         type Value = $t;
 
-                        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-                            formatter.write_str("an ASCII hex string")
+                        fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                            f.write_str("an ASCII hex string")
                         }
 
                         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
                         where
                             E: $crate::serde::de::Error,
                         {
+                            use $crate::serde::de::Unexpected;
+
                             if let Ok(hex) = core::str::from_utf8(v) {
                                 $crate::hashes::hex::FromHex::from_hex(hex).map_err(E::custom)
                             } else {
-                                return Err(E::invalid_value($crate::serde::de::Unexpected::Bytes(v), &self));
+                                return Err(E::invalid_value(Unexpected::Bytes(v), &self));
                             }
                         }
 
@@ -453,8 +452,8 @@ macro_rules! impl_bytes_newtype {
                     impl<'de> $crate::serde::de::Visitor<'de> for BytesVisitor {
                         type Value = $t;
 
-                        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-                            formatter.write_str("a bytestring")
+                        fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                            f.write_str("a bytestring")
                         }
 
                         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
@@ -475,7 +474,7 @@ macro_rules! impl_bytes_newtype {
                 }
             }
         }
-    )
+    };
 }
 
 macro_rules! user_enum {
@@ -531,8 +530,8 @@ macro_rules! user_enum {
                 impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
                     type Value = $name;
 
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str("an enum value")
+                    fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                        f.write_str("an enum value")
                     }
 
                     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -586,9 +585,7 @@ macro_rules! write_err {
 
 /// Asserts a boolean expression at compile time.
 macro_rules! const_assert {
-    ($x:expr) => {
-        {
-            const _: [(); 0 - !$x as usize] = [];
-        }
-    };
+    ($x:expr) => {{
+        const _: [(); 0 - !$x as usize] = [];
+    }};
 }