macros: make target pk and error type optional for translate_* macros

There is no reason callers need to provide these types explicitly. Allow
them to do so anyway for backward compatibility.

(This commit I pulled out of my mega-refactor branch, but it seemed useful
here, so I'm pulling it in now.)

Author: apoelstra

src/descriptor/mod.rs

@@ -674,7 +674,7 @@ impl Descriptor<DescriptorPublicKey> {
                 pk.clone().at_derivation_index(self.0)
             }
 
-            translate_hash_clone!(DescriptorPublicKey, DescriptorPublicKey, ConversionError);
+            translate_hash_clone!(DescriptorPublicKey);
         }
         self.translate_pk(&mut Derivator(index))
             .map_err(|e| e.expect_translator_err("No Context errors while translating"))
@@ -918,7 +918,7 @@ impl Descriptor<DescriptorPublicKey> {
                         .ok_or(Error::MultipathDescLenMismatch),
                 }
             }
-            translate_hash_clone!(DescriptorPublicKey, DescriptorPublicKey, Error);
+            translate_hash_clone!(DescriptorPublicKey);
         }
 
         for (i, desc) in descriptors.iter_mut().enumerate() {
@@ -972,7 +972,7 @@ impl Descriptor<DefiniteDescriptorKey> {
                 pk.derive_public_key(self.0)
             }
 
-            translate_hash_clone!(DefiniteDescriptorKey, bitcoin::PublicKey, ConversionError);
+            translate_hash_clone!(DefiniteDescriptorKey);
         }
 
         let derived = self.translate_pk(&mut Derivator(secp));

src/interpreter/inner.rs

@@ -364,7 +364,7 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
                 Ok(BitcoinKey::Fullkey(*pk))
             }
 
-            translate_hash_clone!(bitcoin::PublicKey, BitcoinKey, Self::Error);
+            translate_hash_clone!(bitcoin::PublicKey);
         }
 
         self.translate_pk_ctx(&mut TranslateFullPk)
@@ -384,7 +384,7 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::key::XOnlyPublicKey,
                 Ok(BitcoinKey::XOnlyPublicKey(*pk))
             }
 
-            translate_hash_clone!(bitcoin::key::XOnlyPublicKey, BitcoinKey, Self::Error);
+            translate_hash_clone!(bitcoin::key::XOnlyPublicKey);
         }
         self.translate_pk_ctx(&mut TranslateXOnlyPk)
             .expect("Translation should succeed")

src/policy/semantic.rs

@@ -89,7 +89,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     ///
     ///     // Handy macro for failing if we encounter any other fragment.
     ///     // See also [`translate_hash_clone!`] for cloning instead of failing.
-    ///     translate_hash_fail!(String, bitcoin::PublicKey, ());
+    ///     translate_hash_fail!(String);
     /// }
     ///
     /// let mut pk_map = HashMap::new();

src/psbt/mod.rs

@@ -999,7 +999,7 @@ impl Translator<DefiniteDescriptorKey> for KeySourceLookUp {
         Ok(derived)
     }
 
-    translate_hash_clone!(DescriptorPublicKey, bitcoin::PublicKey, descriptor::ConversionError);
+    translate_hash_clone!(DescriptorPublicKey);
 }
 
 // Provides generalized access to PSBT fields common to inputs and outputs

src/pub_macros.rs

@@ -47,6 +47,12 @@
 /// ```
 #[macro_export]
 macro_rules! translate_hash_fail {
+    ($source: ty) => {
+        // The target and error type must always be these values; but we let
+        // the user specify them explicitly for compatibility with the version
+        // of this macro that existed before 13.x.
+        translate_hash_fail!($source, Self::TargetPk, Self::Error);
+    };
     ($source: ty, $target:ty, $error_ty: ty) => {
         fn sha256(
             &mut self,
@@ -88,6 +94,12 @@ macro_rules! translate_hash_fail {
 /// See also [`crate::translate_hash_fail`]
 #[macro_export]
 macro_rules! translate_hash_clone {
+    ($source: ty) => {
+        // The target and error type must always be these values; but we let
+        // the user specify them explicitly for compatibility with the version
+        // of this macro that existed before 13.x.
+        translate_hash_clone!($source, Self::TargetPk, Self::Error);
+    };
     ($source: ty, $target:ty, $error_ty: ty) => {
         fn sha256(
             &mut self,