1 files changed, 39 insertions, 11 deletions

diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index f854ca09a..3ad609a00 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -12,6 +12,8 @@ mod subtree_source;
 #[cfg(test)]
 mod tests;
 
+use std::fmt;
+
 pub use tt::{Delimiter, Punct};
 
 use crate::{
@@ -33,6 +35,8 @@ pub enum ExpandError {
     ConversionError,
     InvalidRepeat,
     ProcMacroError(tt::ExpansionError),
+    UnresolvedProcMacro,
+    Other(String),
 }
 
 impl From<tt::ExpansionError> for ExpandError {
@@ -41,6 +45,21 @@ impl From<tt::ExpansionError> for ExpandError {
     }
 }
 
+impl fmt::Display for ExpandError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExpandError::NoMatchingRule => f.write_str("no rule matches input tokens"),
+            ExpandError::UnexpectedToken => f.write_str("unexpected token in input"),
+            ExpandError::BindingError(e) => f.write_str(e),
+            ExpandError::ConversionError => f.write_str("could not convert tokens"),
+            ExpandError::InvalidRepeat => f.write_str("invalid repeat expression"),
+            ExpandError::ProcMacroError(e) => e.fmt(f),
+            ExpandError::UnresolvedProcMacro => f.write_str("unresolved proc macro"),
+            ExpandError::Other(e) => f.write_str(e),
+        }
+    }
+}
+
 pub use crate::syntax_bridge::{
     ast_to_token_tree, parse_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node,
     TokenMap,
@@ -246,33 +265,42 @@ fn validate(pattern: &tt::Subtree) -> Result<(), ParseError> {
     Ok(())
 }
 
-#[derive(Debug)]
-pub struct ExpandResult<T>(pub T, pub Option<ExpandError>);
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ExpandResult<T> {
+    pub value: T,
+    pub err: Option<ExpandError>,
+}
 
 impl<T> ExpandResult<T> {
-    pub fn ok(t: T) -> ExpandResult<T> {
-        ExpandResult(t, None)
+    pub fn ok(value: T) -> Self {
+        Self { value, err: None }
+    }
+
+    pub fn only_err(err: ExpandError) -> Self
+    where
+        T: Default,
+    {
+        Self { value: Default::default(), err: Some(err) }
     }
 
-    pub fn only_err(err: ExpandError) -> ExpandResult<T>
+    pub fn str_err(err: String) -> Self
     where
         T: Default,
     {
-        ExpandResult(Default::default(), Some(err))
+        Self::only_err(ExpandError::Other(err))
     }
 
     pub fn map<U>(self, f: impl FnOnce(T) -> U) -> ExpandResult<U> {
-        ExpandResult(f(self.0), self.1)
+        ExpandResult { value: f(self.value), err: self.err }
     }
 
     pub fn result(self) -> Result<T, ExpandError> {
-        self.1.map(Err).unwrap_or(Ok(self.0))
+        self.err.map(Err).unwrap_or(Ok(self.value))
     }
 }
 
 impl<T: Default> From<Result<T, ExpandError>> for ExpandResult<T> {
-    fn from(result: Result<T, ExpandError>) -> ExpandResult<T> {
-        result
-            .map_or_else(|e| ExpandResult(Default::default(), Some(e)), |it| ExpandResult(it, None))
+    fn from(result: Result<T, ExpandError>) -> Self {
+        result.map_or_else(|e| Self::only_err(e), |it| Self::ok(it))
     }
 }