expression: introduce "unknown name" error variant

This gets rid of several more instances of errstr.

Author: apoelstra

src/expression/error.rs

@@ -83,6 +83,11 @@ pub enum ParseTreeError {
         /// Its byte-index into the string.
         pos: usize,
     },
+    /// A node's name was not recognized.
+    UnknownName {
+        /// The name that was not recognized.
+        name: String,
+    },
 }
 
 impl From<checksum::Error> for ParseTreeError {
@@ -147,6 +152,7 @@ impl fmt::Display for ParseTreeError {
             ParseTreeError::TrailingCharacter { ch, pos } => {
                 write!(f, "trailing data `{}...` (position {})", ch, pos)
             }
+            ParseTreeError::UnknownName { name } => write!(f, "unrecognized name '{}'", name),
         }
     }
 }
@@ -163,7 +169,8 @@ impl std::error::Error for ParseTreeError {
             | ParseTreeError::IllegalCurlyBrace { .. }
             | ParseTreeError::IncorrectName { .. }
             | ParseTreeError::IncorrectNumberOfChildren { .. }
-            | ParseTreeError::TrailingCharacter { .. } => None,
+            | ParseTreeError::TrailingCharacter { .. }
+            | ParseTreeError::UnknownName { .. } => None,
         }
     }
 }

src/miniscript/astelem.rs

@@ -128,11 +128,9 @@ impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Termina
                         .map_err(Error::Parse)
                 })
                 .map(Terminal::MultiA),
-            _ => Err(Error::Unexpected(format!(
-                "{}({} args) while parsing Miniscript",
-                top.name,
-                top.args.len(),
-            ))),
+            x => Err(Error::Parse(crate::ParseError::Tree(crate::ParseTreeError::UnknownName {
+                name: x.to_owned(),
+            }))),
         }?;
         let ms = super::wrap_into_miniscript(unwrapped, frag_wrap)?;
         Ok(ms.node)

src/miniscript/mod.rs

@@ -678,11 +678,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
 ///
 /// Returns the fragment name (right of the `:`) and a list of wrappers
 /// (left of the `:`).
-fn split_expression_name(name: &str) -> Result<(&str, Cow<str>), Error> {
+fn split_expression_name(full_name: &str) -> Result<(&str, Cow<str>), Error> {
     let mut aliased_wrap;
     let frag_name;
     let frag_wrap;
-    let mut name_split = name.split(':');
+    let mut name_split = full_name.split(':');
     match (name_split.next(), name_split.next(), name_split.next()) {
         (None, _, _) => {
             frag_name = "";
@@ -702,7 +702,9 @@ fn split_expression_name(name: &str) -> Result<(&str, Cow<str>), Error> {
         }
         (Some(wrap), Some(name), None) => {
             if wrap.is_empty() {
-                return Err(Error::Unexpected(name.to_owned()));
+                return Err(Error::Parse(crate::ParseError::Tree(
+                    crate::ParseTreeError::UnknownName { name: full_name.to_owned() },
+                )));
             }
             if name == "pk" {
                 frag_name = "pk_k";
@@ -720,7 +722,7 @@ fn split_expression_name(name: &str) -> Result<(&str, Cow<str>), Error> {
             }
         }
         (Some(_), Some(_), Some(_)) => {
-            return Err(Error::MultiColon(name.to_owned()));
+            return Err(Error::MultiColon(full_name.to_owned()));
         }
     }
     Ok((frag_name, frag_wrap))

src/policy/concrete.rs

@@ -19,6 +19,8 @@ use {
     core::cmp::Reverse,
 };
 
+#[cfg(feature = "compiler")]
+use crate::errstr;
 use crate::expression::{self, FromTree};
 use crate::iter::{Tree, TreeLike};
 use crate::miniscript::types::extra_props::TimelockInfo;
@@ -27,8 +29,7 @@ use crate::sync::Arc;
 #[cfg(all(doc, not(feature = "compiler")))]
 use crate::Descriptor;
 use crate::{
-    errstr, AbsLockTime, Error, ForEachKey, FromStrKey, MiniscriptKey, RelLockTime, Threshold,
-    Translator,
+    AbsLockTime, Error, ForEachKey, FromStrKey, MiniscriptKey, RelLockTime, Threshold, Translator,
 };
 
 /// Maximum TapLeafs allowed in a compiled TapTree
@@ -940,7 +941,9 @@ impl<Pk: FromStrKey> Policy<Pk> {
                 .map_err(Error::ParseThreshold)?
                 .translate_by_index(|i| Policy::from_tree(&top.args[1 + i]).map(Arc::new))
                 .map(Policy::Thresh),
-            _ => Err(errstr(top.name)),
+            x => Err(Error::Parse(crate::ParseError::Tree(crate::ParseTreeError::UnknownName {
+                name: x.to_owned(),
+            }))),
         }
         .map(|res| (frag_prob, res))
     }

src/policy/semantic.rs

@@ -356,7 +356,9 @@ impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {
                     .translate_by_index(|i| Policy::from_tree(&top.args[1 + i]).map(Arc::new))
                     .map(Policy::Thresh)
             }
-            _ => Err(errstr(top.name)),
+            x => Err(Error::Parse(crate::ParseError::Tree(crate::ParseTreeError::UnknownName {
+                name: x.to_owned(),
+            }))),
         }
     }
 }