Implement infallible for errors

Creates a new macro `impl_from_infallible`, and applies it to custom
error types in the codebase.

Closes rust-bitcoin#1222.

Author: liamaharon

CONTRIBUTING.md

@@ -290,6 +290,7 @@ More specifically an error should
 - derive `Debug, Clone, PartialEq, Eq` (and `Copy` iff not `non_exhaustive`).
 - implement Display using `write_err!()` macro if a variant contains an inner error source.
 - have `Error` suffix
+- call `internals::impl_from_infallible!
 - implement `std::error::Error` if they are public (feature gated on "std").
 
 ```rust
@@ -302,6 +303,9 @@ pub enum Error {
     /// Documentation for variant B.
     B,
 }
+
+internals::impl_from_infallible!(Error);
+
 ```
 
 

Cargo-minimal.lock

@@ -12,6 +12,7 @@ checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"
 name = "base58check"
 version = "0.1.0"
 dependencies = [
+ "bitcoin-internals",
  "bitcoin_hashes",
  "hex-conservative",
 ]

Cargo-recent.lock

@@ -12,6 +12,7 @@ checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
 name = "base58check"
 version = "0.1.0"
 dependencies = [
+ "bitcoin-internals",
  "bitcoin_hashes",
  "hex-conservative",
 ]

base58/Cargo.toml

@@ -22,6 +22,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
 hashes = { package = "bitcoin_hashes", version = "0.13.0", default-features = false, features = ["alloc"] }
+internals = { package = "bitcoin-internals", version = "0.2.0" }
 
 [dev-dependencies]
 hex = { package = "hex-conservative", version = "0.1.1", default-features = false, features = ["alloc"] }

base58/src/lib.rs

@@ -228,6 +228,8 @@ pub enum Error {
     TooShort(usize),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/address/error.rs

@@ -41,6 +41,8 @@ pub enum FromScriptError {
     WitnessVersion(witness_version::TryFromError),
 }
 
+internals::impl_from_infallible!(FromScriptError);
+
 impl fmt::Display for FromScriptError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use FromScriptError::*;
@@ -82,6 +84,8 @@ pub enum P2shError {
     ExcessiveScriptSize,
 }
 
+internals::impl_from_infallible!(P2shError);
+
 impl fmt::Display for P2shError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use P2shError::*;
@@ -135,6 +139,8 @@ pub enum ParseError {
     UnknownHrp(UnknownHrpError),
 }
 
+internals::impl_from_infallible!(ParseError);
+
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParseError::*;

bitcoin/src/bip152.rs

@@ -28,6 +28,8 @@ pub enum Error {
     InvalidPrefill,
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {

bitcoin/src/bip158.rs

@@ -77,6 +77,8 @@ pub enum Error {
     Io(io::Error),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl Display for Error {
     fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
         use Error::*;

bitcoin/src/bip32.rs

@@ -491,6 +491,8 @@ pub enum Error {
     InvalidPublicKeyHexLength(usize),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/blockdata/block.rs

@@ -420,6 +420,8 @@ pub enum Bip34Error {
     NegativeHeight,
 }
 
+internals::impl_from_infallible!(Bip34Error);
+
 impl fmt::Display for Bip34Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Bip34Error::*;
@@ -456,6 +458,8 @@ pub enum ValidationError {
     BadTarget,
 }
 
+internals::impl_from_infallible!(ValidationError);
+
 impl fmt::Display for ValidationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ValidationError::*;

bitcoin/src/blockdata/locktime/absolute.rs

@@ -626,6 +626,8 @@ pub enum Error {
     Parse(ParseIntError),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;
@@ -723,6 +725,8 @@ pub enum OperationError {
     InvalidComparison,
 }
 
+internals::impl_from_infallible!(OperationError);
+
 impl fmt::Display for OperationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use OperationError::*;
@@ -754,6 +758,8 @@ enum ParseError {
     Conversion(i64),
 }
 
+internals::impl_from_infallible!(ParseError);
+
 impl ParseError {
     fn invalid_int<S: Into<String>>(s: S) -> impl FnOnce(core::num::ParseIntError) -> Self {
         move |source| Self::InvalidInteger { source, input: s.into() }

bitcoin/src/blockdata/locktime/relative.rs

@@ -282,6 +282,8 @@ pub enum Error {
     IncompatibleTime(LockTime, Time),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/blockdata/script/mod.rs

@@ -699,6 +699,8 @@ pub enum Error {
     Serialization,
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;
@@ -737,6 +739,8 @@ enum UintError {
     NumericOverflow,
 }
 
+internals::impl_from_infallible!(UintError);
+
 impl From<UintError> for Error {
     fn from(error: UintError) -> Self {
         match error {

bitcoin/src/blockdata/script/witness_program.rs

@@ -135,6 +135,8 @@ pub enum Error {
     InvalidSegwitV0Length(usize),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/blockdata/script/witness_version.rs

@@ -175,6 +175,8 @@ pub enum FromStrError {
     Invalid(TryFromError),
 }
 
+internals::impl_from_infallible!(FromStrError);
+
 impl fmt::Display for FromStrError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use FromStrError::*;
@@ -216,6 +218,8 @@ pub enum TryFromInstructionError {
     DataPush,
 }
 
+internals::impl_from_infallible!(TryFromInstructionError);
+
 impl fmt::Display for TryFromInstructionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use TryFromInstructionError::*;

bitcoin/src/blockdata/transaction.rs

@@ -130,6 +130,8 @@ pub enum ParseOutPointError {
     VoutNotCanonical,
 }
 
+internals::impl_from_infallible!(ParseOutPointError);
+
 impl fmt::Display for ParseOutPointError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParseOutPointError::*;

bitcoin/src/consensus/encode.rs

@@ -61,6 +61,8 @@ pub enum Error {
     UnsupportedSegwitFlag(u8),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/consensus/serde.rs

@@ -368,6 +368,8 @@ enum DecodeError<E> {
     Other(E),
 }
 
+internals::impl_from_infallible!(DecodeError<E>);
+
 // not a trait impl because we panic on some variants
 fn consensus_error_into_serde<E: serde::de::Error>(error: ConsensusError) -> E {
     match error {

bitcoin/src/consensus/validation.rs

@@ -209,6 +209,8 @@ pub enum TxVerifyError {
     UnknownSpentOutput(OutPoint),
 }
 
+internals::impl_from_infallible!(TxVerifyError);
+
 impl fmt::Display for TxVerifyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use TxVerifyError::*;

bitcoin/src/crypto/ecdsa.rs

@@ -213,6 +213,8 @@ pub enum Error {
     Secp256k1(secp256k1::Error),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

bitcoin/src/crypto/key.rs

@@ -896,6 +896,8 @@ pub enum FromSliceError {
     InvalidLength(usize),
 }
 
+internals::impl_from_infallible!(FromSliceError);
+
 impl fmt::Display for FromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use FromSliceError::*;
@@ -934,6 +936,8 @@ pub enum FromWifError {
     Secp256k1(secp256k1::Error),
 }
 
+internals::impl_from_infallible!(FromWifError);
+
 impl fmt::Display for FromWifError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use FromWifError::*;
@@ -974,6 +978,8 @@ pub enum ParsePublicKeyError {
     InvalidHexLength(usize),
 }
 
+internals::impl_from_infallible!(ParsePublicKeyError);
+
 impl fmt::Display for ParsePublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParsePublicKeyError::*;
@@ -1010,6 +1016,8 @@ pub enum ParseCompressedPublicKeyError {
     Hex(hex::HexToArrayError),
 }
 
+internals::impl_from_infallible!(ParseCompressedPublicKeyError);
+
 impl fmt::Display for ParseCompressedPublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParseCompressedPublicKeyError::*;

bitcoin/src/crypto/sighash.rs

@@ -275,6 +275,8 @@ pub enum PrevoutsIndexError {
     InvalidAllIndex,
 }
 
+internals::impl_from_infallible!(PrevoutsIndexError);
+
 impl fmt::Display for PrevoutsIndexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use PrevoutsIndexError::*;
@@ -1151,6 +1153,8 @@ pub enum TaprootError {
     InvalidSighashType(u32),
 }
 
+internals::impl_from_infallible!(TaprootError);
+
 impl fmt::Display for TaprootError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use TaprootError::*;
@@ -1208,6 +1212,8 @@ pub enum P2wpkhError {
     NotP2wpkhScript,
 }
 
+internals::impl_from_infallible!(P2wpkhError);
+
 impl From<transaction::InputsIndexError> for P2wpkhError {
     fn from(value: transaction::InputsIndexError) -> Self {
         P2wpkhError::Sighash(value)
@@ -1273,6 +1279,8 @@ pub enum AnnexError {
     IncorrectPrefix(u8),
 }
 
+internals::impl_from_infallible!(AnnexError);
+
 impl fmt::Display for AnnexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use AnnexError::*;
@@ -1379,6 +1387,8 @@ pub enum SigningDataError<E> {
     Sighash(E),
 }
 
+internals::impl_from_infallible!(SigningDataError<E>);
+
 impl<E> SigningDataError<E> {
     /// Returns the sighash variant, panicking if it's IO.
     ///

bitcoin/src/crypto/taproot.rs

@@ -97,6 +97,8 @@ pub enum SigFromSliceError {
     InvalidSignatureSize(usize),
 }
 
+internals::impl_from_infallible!(SigFromSliceError);
+
 impl fmt::Display for SigFromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use SigFromSliceError::*;

bitcoin/src/merkle_tree/block.rs

@@ -498,6 +498,8 @@ pub enum MerkleBlockError {
     IdenticalHashesFound,
 }
 
+internals::impl_from_infallible!(MerkleBlockError);
+
 impl fmt::Display for MerkleBlockError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use MerkleBlockError::*;

bitcoin/src/psbt/error.rs

@@ -103,6 +103,8 @@ pub enum Error {
     Io(io::Error),
 }
 
+internals::impl_from_infallible!(Error);
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;