refactor: use anyhow::Error in place of String

Use the anyhow crate for errors where we're currently just using String.
This makes it easier to add context to errors and avoids the need to
convert to a string when bubbling up errors.

Also box the `Error` field in `RichError` to reduce its size and keep
clippy happy.

Author: canndrew

Cargo.lock

@@ -32,6 +32,7 @@ either = "1.12.0"
 itertools = "0.13.0"
 arbitrary = { version = "1", optional = true, features = ["derive"] }
 clap = "4.5.37"
+anyhow = "1.0.98"
 
 [target.wasm32-unknown-unknown.dependencies]
 getrandom = { version = "0.2", features = ["js"] }

Cargo.toml

@@ -1,3 +1 @@
 msrv = "1.78.0"
-# We have an error type, `RichError`, of size 144. This is pushing it but probably fine.
-large-error-threshold = 145

clippy.toml

@@ -195,7 +195,7 @@ impl<T> WithFile<T> for Result<T, RichError> {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct RichError {
     /// The error that occurred.
-    error: Error,
+    error: Box<Error>,
     /// Area that the error spans inside the file.
     span: Span,
     /// File in which the error occurred.
@@ -208,7 +208,7 @@ impl RichError {
     /// Create a new error with context.
     pub fn new(error: Error, span: Span) -> RichError {
         RichError {
-            error,
+            error: Box::new(error),
             span,
             file: None,
         }
@@ -266,7 +266,7 @@ impl std::error::Error for RichError {}
 
 impl From<RichError> for Error {
     fn from(error: RichError) -> Self {
-        error.error
+        *error.error
     }
 }
 

src/error.rs

@@ -51,7 +51,7 @@ impl TemplateProgram {
     /// ## Errors
     ///
     /// The string is not a valid Simfony program.
-    pub fn new<Str: Into<Arc<str>>>(s: Str) -> Result<Self, String> {
+    pub fn new<Str: Into<Arc<str>>>(s: Str) -> anyhow::Result<Self> {
         let file = s.into();
         let parse_program = parse::Program::parse_from_str(&file)?;
         let ast_program = ast::Program::analyze(&parse_program).with_file(Arc::clone(&file))?;
@@ -76,10 +76,9 @@ impl TemplateProgram {
         &self,
         arguments: Arguments,
         include_debug_symbols: bool,
-    ) -> Result<CompiledProgram, String> {
+    ) -> anyhow::Result<CompiledProgram> {
         arguments
-            .is_consistent(self.simfony.parameters())
-            .map_err(|error| error.to_string())?;
+            .is_consistent(self.simfony.parameters())?;
         Ok(CompiledProgram {
             debug_symbols: self.simfony.debug_symbols(self.file.as_ref()),
             simplicity: self
@@ -121,7 +120,7 @@ impl CompiledProgram {
         s: Str,
         arguments: Arguments,
         include_debug_symbols: bool,
-    ) -> Result<Self, String> {
+    ) -> anyhow::Result<Self> {
         TemplateProgram::new(s)
             .and_then(|template| template.instantiate(arguments, include_debug_symbols))
     }
@@ -142,7 +141,7 @@ impl CompiledProgram {
     ///
     /// - Witness values have a different type than declared in the Simfony program.
     /// - There are missing witness values.
-    pub fn satisfy(&self, witness_values: WitnessValues) -> Result<SatisfiedProgram, String> {
+    pub fn satisfy(&self, witness_values: WitnessValues) -> anyhow::Result<SatisfiedProgram> {
         self.satisfy_with_env(witness_values, None)
     }
 
@@ -157,17 +156,16 @@ impl CompiledProgram {
         &self,
         witness_values: WitnessValues,
         env: Option<&ElementsEnv<Arc<elements::Transaction>>>,
-    ) -> Result<SatisfiedProgram, String> {
+    ) -> anyhow::Result<SatisfiedProgram> {
         witness_values
-            .is_consistent(&self.witness_types)
-            .map_err(|e| e.to_string())?;
+            .is_consistent(&self.witness_types)?;
         let simplicity_witness = named::to_witness_node(&self.simplicity, witness_values);
         let simplicity_redeem = match env {
-            Some(env) => simplicity_witness.finalize_pruned(env),
-            None => simplicity_witness.finalize_unpruned(),
+            Some(env) => simplicity_witness.finalize_pruned(env)?,
+            None => simplicity_witness.finalize_unpruned()?,
         };
         Ok(SatisfiedProgram {
-            simplicity: simplicity_redeem.map_err(|e| e.to_string())?,
+            simplicity: simplicity_redeem,
             debug_symbols: self.debug_symbols.clone(),
         })
     }
@@ -193,7 +191,7 @@ impl SatisfiedProgram {
         arguments: Arguments,
         witness_values: WitnessValues,
         include_debug_symbols: bool,
-    ) -> Result<Self, String> {
+    ) -> anyhow::Result<Self> {
         let compiled = CompiledProgram::new(s, arguments, include_debug_symbols)?;
         compiled.satisfy(witness_values)
     }
@@ -620,7 +618,7 @@ fn main() {
         ) {
             Ok(_) => panic!("Accepted faulty program"),
             Err(error) => {
-                if !error.contains("Expected expression of type `bool`, found type `()`") {
+                if !error.to_string().contains("Expected expression of type `bool`, found type `()`") {
                     panic!("Unexpected error: {error}")
                 }
             }

src/lib.rs

@@ -1,20 +1,12 @@
 use base64::display::Base64Display;
 use base64::engine::general_purpose::STANDARD;
 use clap::{Arg, ArgAction, Command};
+use anyhow::Context;
 
 use simfony::{Arguments, CompiledProgram};
 use std::env;
 
-// Directly returning Result<(), String> prints the error using Debug
-// Add indirection via run() to print errors using Display
-fn main() {
-    if let Err(error) = run() {
-        eprintln!("{error}");
-        std::process::exit(1);
-    }
-}
-
-fn run() -> Result<(), String> {
+fn main() -> anyhow::Result<()> {
     let command = {
         Command::new(env!("CARGO_BIN_NAME"))
         .about(
@@ -56,7 +48,10 @@ fn run() -> Result<(), String> {
 
     let prog_file = matches.get_one::<String>("prog_file").unwrap();
     let prog_path = std::path::Path::new(prog_file);
-    let prog_text = std::fs::read_to_string(prog_path).map_err(|e| e.to_string())?;
+    let prog_text = {
+        std::fs::read_to_string(prog_path)
+        .with_context(|| format!("Failed to read {}", prog_path.display()))?
+    };
     let include_debug_symbols = matches.get_flag("debug");
 
     let compiled = CompiledProgram::new(prog_text, Arguments::default(), include_debug_symbols)?;
@@ -65,10 +60,16 @@ fn run() -> Result<(), String> {
     let witness_opt = {
         matches
         .get_one::<String>("wit_file")
-        .map(|wit_file| -> Result<simfony::WitnessValues, String> {
+        .map(|wit_file| -> anyhow::Result<simfony::WitnessValues> {
             let wit_path = std::path::Path::new(wit_file);
-            let wit_text = std::fs::read_to_string(wit_path).map_err(|e| e.to_string())?;
-            let witness = serde_json::from_str::<simfony::WitnessValues>(&wit_text).unwrap();
+            let wit_text = {
+                std::fs::read_to_string(wit_path)
+                .with_context(|| format!("Failed to read {}", wit_path.display()))?
+            };
+            let witness = {
+                serde_json::from_str::<simfony::WitnessValues>(&wit_text)
+                .with_context(|| format!("Failed to parse file {}", wit_path.display()))?
+            };
             Ok(witness)
         })
         .transpose()?

src/main.rs

@@ -240,7 +240,7 @@ mod tests {
             Ok(_) => panic!("Ill-typed witness assignment was falsely accepted"),
             Err(error) => assert_eq!(
                 "Witness `A` was declared with type `u32` but its assigned value is of type `u16`",
-                error
+                error.to_string(),
             ),
         }
     }
@@ -259,6 +259,7 @@ fn main() {
             Ok(_) => panic!("Witness outside main was falsely accepted"),
             Err(error) => {
                 assert!(error
+                    .to_string()
                     .contains("Witness expressions are not allowed outside the `main` function"))
             }
         }