bitcoin: Stop using impl_parse_str_from_int

We just got bitten by macros *again*. Feature gates only work if the
feature exists, using a macro with feature gates in other crates is
error prone and can fail silently. This time, eventually, the tooling
found our mistake.

Stop using `impl_parse_str_from_int` and just write the code.

Say after me, "macros are a constant source of trouble and should
probably be avoided".

Author: tcharding

bitcoin/src/blockdata/locktime/absolute.rs

@@ -8,16 +8,18 @@
 
 use core::cmp::Ordering;
 use core::fmt;
+use core::str::FromStr;
 
 use io::{Read, Write};
 #[cfg(all(test, mutate))]
 use mutagen::mutate;
-use units::parse;
+use units::parse::{self, ParseIntError};
 
 #[cfg(doc)]
 use crate::absolute;
 use crate::consensus::encode::{self, Decodable, Encodable};
 use crate::error::{ContainsPrefixError, MissingPrefixError, PrefixedHexError, UnprefixedHexError};
+use crate::prelude::{Box, String};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
@@ -284,7 +286,37 @@ impl LockTime {
     }
 }
 
-units::impl_parse_str_from_int_infallible!(LockTime, u32, from_consensus);
+impl FromStr for LockTime {
+    type Err = ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        parse::int::<u32, &str>(s).map(LockTime::from_consensus)
+    }
+}
+
+impl TryFrom<&str> for LockTime {
+    type Error = ParseIntError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        LockTime::from_str(s)
+    }
+}
+
+impl TryFrom<String> for LockTime {
+    type Error = ParseIntError;
+
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        LockTime::from_str(&s)
+    }
+}
+
+impl TryFrom<Box<str>> for LockTime {
+    type Error = ParseIntError;
+
+    fn try_from(s: Box<str>) -> Result<Self, Self::Error> {
+        LockTime::from_str(&s)
+    }
+}
 
 impl From<Height> for LockTime {
     #[inline]

bitcoin/src/blockdata/transaction.rs

@@ -11,12 +11,13 @@
 //! This module provides the structures and functions needed to support transactions.
 //!
 
-use core::{cmp, fmt, str};
+use core::{cmp, fmt};
+use core::str::FromStr;
 
 use hashes::{sha256d, Hash};
 use internals::write_err;
 use io::{Read, Write};
-use units::parse;
+use units::parse::{self, ParseIntError};
 
 use super::Weight;
 use crate::blockdata::locktime::absolute::{self, Height, Time};
@@ -527,7 +528,37 @@ impl fmt::Debug for Sequence {
     }
 }
 
-units::impl_parse_str_from_int_infallible!(Sequence, u32, from_consensus);
+impl FromStr for Sequence {
+    type Err = ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        parse::int::<u32, &str>(s).map(Sequence::from_consensus)
+    }
+}
+
+impl TryFrom<&str> for Sequence {
+    type Error = ParseIntError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Sequence::from_str(s)
+    }
+}
+
+impl TryFrom<String> for Sequence {
+    type Error = ParseIntError;
+
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        Sequence::from_str(&s)
+    }
+}
+
+impl TryFrom<Box<str>> for Sequence {
+    type Error = ParseIntError;
+
+    fn try_from(s: Box<str>) -> Result<Self, Self::Error> {
+        Sequence::from_str(&s)
+    }
+}
 
 /// Bitcoin transaction output.
 ///

units/src/parse.rs

@@ -160,7 +160,6 @@ macro_rules! impl_parse_str_from_int_infallible {
                 $crate::parse::int::<$inner, &str>(s).map($to::$fn)
             }
         }
-
     }
 }