policy: Remove FromStr implementation

I would like to keep an implementation of FromStr, but I don't want to
copy all of the expression parsing from Miniscript.

We don't need FromStr right now, and Miniscript can implement a parser
using <Tree as FromStr> and FromTree<Policy>.

We might want to implement a parser on the Simplicity side, which might
use ideas from the dag module or simplang.

Removing FromStr also means removing the associated fuzz test.

Author: uncomputable

.github/workflows/fuzz.yml

@@ -19,7 +19,6 @@ jobs:
 c_rust_merkle,
 decode_natural,
 decode_program,
-parse_compile,
         ]
     steps:
       - name: Install test dependencies

fuzz/Cargo.toml

@@ -27,7 +27,3 @@ path = "fuzz_targets/decode_natural.rs"
 [[bin]]
 name = "decode_program"
 path = "fuzz_targets/decode_program.rs"
-
-#[[bin]]
-#name = "parse_compile"
-#path = "fuzz_targets/parse_compile.rs"

fuzz/fuzz_targets/parse_compile.rs

@@ -14,105 +14,3 @@ macro_rules! decode_bits {
         }
     };
 }
-
-/// Copied from rust-miniscript
-///
-/// A macro that implements serde serialization and deserialization using the
-/// `fmt::Display` and `str::FromStr` traits.
-#[cfg(feature = "elements")]
-macro_rules! serde_string_impl_pk {
-    ($name:ident, $expecting:expr $(, $gen:ident; $gen_con:ident)*) => {
-        #[cfg(feature = "serde")]
-        impl<'de, Pk $(, $gen)*> $crate::serde::Deserialize<'de> for $name<Pk $(, $gen)*>
-        where
-            Pk: crate::miniscript::ToPublicKey + core::str::FromStr,
-            Pk::Sha256: core::str::FromStr,
-            Pk::Hash256: core::str::FromStr,
-            Pk::Ripemd160: core::str::FromStr,
-            Pk::Hash160: core::str::FromStr,
-            <Pk as core::str::FromStr>::Err: core::fmt::Display,
-            <<Pk as crate::miniscript::MiniscriptKey>::Sha256 as core::str::FromStr>::Err:
-                core::fmt::Display,
-            <<Pk as crate::miniscript::MiniscriptKey>::Hash256 as core::str::FromStr>::Err:
-                core::fmt::Display,
-            <<Pk as crate::miniscript::MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err:
-                core::fmt::Display,
-            <<Pk as crate::miniscript::MiniscriptKey>::Hash160 as core::str::FromStr>::Err:
-                core::fmt::Display,
-            $($gen : $gen_con,)*
-        {
-            fn deserialize<D>(deserializer: D) -> Result<$name<Pk $(, $gen)*>, D::Error>
-            where
-                D: $crate::serde::de::Deserializer<'de>,
-            {
-                use core::fmt::{self, Formatter};
-                use core::marker::PhantomData;
-                use core::str::FromStr;
-
-                #[allow(unused_parens)]
-                struct Visitor<Pk $(, $gen)*>(PhantomData<(Pk $(, $gen)*)>);
-                impl<'de, Pk $(, $gen)*> $crate::serde::de::Visitor<'de> for Visitor<Pk $(, $gen)*>
-                where
-                    Pk: crate::miniscript::ToPublicKey + core::str::FromStr,
-                    Pk::Sha256: core::str::FromStr,
-                    Pk::Hash256: core::str::FromStr,
-                    Pk::Ripemd160: core::str::FromStr,
-                    Pk::Hash160: core::str::FromStr,
-                    <Pk as core::str::FromStr>::Err: core::fmt::Display,
-                    <<Pk as crate::miniscript::MiniscriptKey>::Sha256 as core::str::FromStr>::Err:
-                        core::fmt::Display,
-                    <<Pk as crate::miniscript::MiniscriptKey>::Hash256 as core::str::FromStr>::Err:
-                        core::fmt::Display,
-                    <<Pk as crate::miniscript::MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err:
-                        core::fmt::Display,
-                    <<Pk as crate::miniscript::MiniscriptKey>::Hash160 as core::str::FromStr>::Err:
-                        core::fmt::Display,
-                    $($gen: $gen_con,)*
-                {
-                    type Value = $name<Pk $(, $gen)*>;
-
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str($expecting)
-                    }
-
-                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        $name::from_str(v).map_err(E::custom)
-                    }
-
-                    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(v)
-                    }
-
-                    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(&v)
-                    }
-                }
-
-                deserializer.deserialize_str(Visitor(PhantomData))
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl<'de, Pk $(, $gen)*> $crate::serde::Serialize for $name<Pk $(, $gen)*>
-        where
-            Pk: crate::miniscript::ToPublicKey,
-            $($gen: $gen_con,)*
-        {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::serde::Serializer,
-            {
-                serializer.collect_str(&self)
-            }
-        }
-    };
-}