Consolidate error types

Cargo.toml

@@ -49,6 +49,7 @@ chumsky = { version = "0.13.0", features = ["pratt"] }
 clap = { version = "4.5.60", features = ["derive"] }
 gmp-mpfr-sys = { version = "~1.7", default-features = false, optional = true }
 rug = { version = "1.30.0", default-features = false, features = ["float", "rational", "std"] }
+thiserror = "2.0.19"
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 dirs = "6.0.0"

crates/val-wasm/src/lib.rs

@@ -44,8 +44,8 @@ pub fn parse(input: &str) -> Result<JsValue, JsValue> {
           .into_iter()
           .map(|error| ValError {
             kind: ErrorKind::Parser,
-            message: error.message,
-            range: converter.convert(Range::from(error.span)),
+            message: error.to_string(),
+            range: converter.convert(Range::from(error.span())),
           })
           .collect::<Vec<ValError>>(),
       )
@@ -71,8 +71,8 @@ pub fn evaluate(input: &str) -> Result<JsValue, JsValue> {
         Err(error) => Err(
           to_value(&[ValError {
             kind: ErrorKind::Evaluator,
-            message: error.message,
-            range: converter.convert(Range::from(error.span)),
+            message: error.to_string(),
+            range: converter.convert(Range::from(error.span())),
           }])
           .unwrap(),
         ),
@@ -84,8 +84,8 @@ pub fn evaluate(input: &str) -> Result<JsValue, JsValue> {
           .into_iter()
           .map(|error| ValError {
             kind: ErrorKind::Parser,
-            message: error.message,
-            range: converter.convert(Range::from(error.span)),
+            message: error.to_string(),
+            range: converter.convert(Range::from(error.span())),
           })
           .collect::<Vec<ValError>>(),
       )

src/builtins.rs

@@ -269,7 +269,7 @@ fn acsc<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
 
   let reciprocal = Number::from(1_i64)
     .div(argument, payload.config)
-    .map_err(|error| Error::new(payload.span, error.to_string()))?;
+    .map_err(|error| error.with_span(payload.span))?;
 
   Ok(Value::Number(reciprocal.asin(payload.config)))
 }
@@ -304,7 +304,7 @@ fn asec<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
 
   let reciprocal = Number::from(1_i64)
     .div(argument, payload.config)
-    .map_err(|error| Error::new(payload.span, error.to_string()))?;
+    .map_err(|error| error.with_span(payload.span))?;
 
   Ok(Value::Number(reciprocal.acos(payload.config)))
 }
@@ -403,7 +403,7 @@ fn cot<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
   Number::from(1_i64)
     .div(&tan, payload.config)
     .map(Value::Number)
-    .map_err(|error| Error::new(payload.span, error.to_string()))
+    .map_err(|error| error.with_span(payload.span))
 }
 
 fn csc<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
@@ -421,7 +421,7 @@ fn csc<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
   Number::from(1_i64)
     .div(&sin, payload.config)
     .map(Value::Number)
-    .map_err(|error| Error::new(payload.span, error.to_string()))
+    .map_err(|error| error.with_span(payload.span))
 }
 
 fn e<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
@@ -775,7 +775,7 @@ fn sec<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {
   Number::from(1_i64)
     .div(&cos, payload.config)
     .map(Value::Number)
-    .map_err(|error| Error::new(payload.span, error.to_string()))
+    .map_err(|error| error.with_span(payload.span))
 }
 
 fn sin<'a>(payload: &BuiltinFunctionPayload<'a>) -> Result<Value<'a>, Error> {

src/error.rs

@@ -1,36 +1,62 @@
 use super::*;
 
-#[derive(Debug, PartialEq)]
-pub struct Error {
-  pub message: String,
-  pub span: Span,
+#[derive(Debug, PartialEq, thiserror::Error)]
+pub enum Error {
+  #[error("division by zero")]
+  DivisionByZero,
+  #[error("invalid decimal")]
+  InvalidDecimal,
+  #[error("{0}")]
+  Message(String),
+  #[error("modulo by zero")]
+  ModuloByZero,
+  #[error("{error}")]
+  Spanned { error: Box<Self>, span: Span },
+  #[error("zero cannot be raised to a negative power")]
+  ZeroToNegativePower,
 }
 
 impl Error {
   pub fn new(span: Span, message: impl Into<String>) -> Self {
-    Self {
-      message: message.into(),
-      span,
-    }
+    Self::Message(message.into()).with_span(span)
   }
 
   #[must_use]
   pub fn report<'a>(&self, id: &'a str) -> Report<'a, (&'a str, Range<usize>)> {
-    let span_range = self.span.into_range();
+    let span_range = self.span().into_range();
 
     let mut report = Report::build(
       ReportKind::Custom("error", Color::Red),
       (id, span_range.clone()),
     )
     .with_config(ariadne::Config::new().with_index_type(IndexType::Byte))
-    .with_message(&self.message);
+    .with_message(self.to_string());
 
     report = report.with_label(
       Label::new((id, span_range))
-        .with_message(&self.message)
+        .with_message(self.to_string())
         .with_color(Color::Red),
     );
 
     report.finish()
   }
+
+  #[must_use]
+  pub fn span(&self) -> Span {
+    match self {
+      Self::Spanned { span, .. } => *span,
+      _ => Span::from(0..0),
+    }
+  }
+
+  #[must_use]
+  pub fn with_span(self, span: Span) -> Self {
+    match self {
+      Self::Spanned { error, .. } => Self::Spanned { error, span },
+      error => Self::Spanned {
+        error: Box::new(error),
+        span,
+      },
+    }
+  }
 }

src/evaluator.rs

@@ -174,7 +174,7 @@ impl<'a> Evaluator<'a> {
         lhs_num
           .div(rhs_num, self.environment.config)
           .map(Value::Number)
-          .map_err(|error| Error::new(rhs.1, error.to_string()))
+          .map_err(|error| error.with_span(rhs.1))
       }
       Expression::BinaryOp(BinaryOp::Equal, lhs, rhs) => Ok(Value::Boolean(
         self.evaluate_expression(lhs)? == self.evaluate_expression(rhs)?,
@@ -246,7 +246,7 @@ impl<'a> Evaluator<'a> {
         lhs_num
           .rem(rhs_num, self.environment.config)
           .map(Value::Number)
-          .map_err(|error| Error::new(rhs.1, error.to_string()))
+          .map_err(|error| error.with_span(rhs.1))
       }
       Expression::BinaryOp(BinaryOp::Multiply, lhs, rhs) => Ok(Value::Number(
         self.evaluate_expression(lhs)?.number(lhs.1)?.mul(
@@ -269,7 +269,7 @@ impl<'a> Evaluator<'a> {
         lhs_num
           .pow(rhs_num, self.environment.config)
           .map(Value::Number)
-          .map_err(|error| Error::new(rhs.1, error.to_string()))
+          .map_err(|error| error.with_span(rhs.1))
       }
       Expression::BinaryOp(BinaryOp::Subtract, lhs, rhs) => Ok(Value::Number(
         self.evaluate_expression(lhs)?.number(lhs.1)?.sub(

src/lib.rs

@@ -28,29 +28,19 @@ use {
 };
 
 pub use crate::{
-  arithmetic_error::ArithmeticError,
-  builtin::Builtin,
-  builtin_arity::BuiltinArity,
+  builtin::Builtin, builtin_arity::BuiltinArity,
   builtin_function::BuiltinFunction,
-  builtin_function_payload::BuiltinFunctionPayload,
-  completion::Completion,
-  config::Config,
-  environment::Environment,
-  error::Error,
-  evaluator::Evaluator,
-  function::Function,
-  number::{Number, ParseDecimalError},
-  parser::parse,
-  rounding_mode::RoundingMode,
-  value::Value,
+  builtin_function_payload::BuiltinFunctionPayload, completion::Completion,
+  config::Config, environment::Environment, error::Error, evaluator::Evaluator,
+  function::Function, number::Number, parser::parse,
+  rounding_mode::RoundingMode, value::Value,
 };
 
 pub type Span = SimpleSpan<usize>;
 pub type Spanned<T> = (T, Span);
 
 type Result<T = (), E = anyhow::Error> = std::result::Result<T, E>;
 
-mod arithmetic_error;
 pub mod ast;
 mod builtin;
 mod builtin_arity;