fix: derive Clone for ParseProgramError and lower-level errors (#383)

quil-rs/src/parser/error/error.rs

@@ -17,6 +17,7 @@ use crate::parser::error::{ErrorInput, GenericParseError, InternalError};
 use nom::error::{Error as NomError, ParseError};
 use std::convert::Infallible;
 use std::fmt;
+use std::sync::Arc;
 use thiserror::__private::AsDynError;
 
 /// An error that may occur while parsing.
@@ -34,7 +35,7 @@ use thiserror::__private::AsDynError;
 /// user-readable backtrace of the errors that caused this one.
 ///
 /// When displaying errors to end-users, prefer the alternate format for easier debugging.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Error<E = Infallible>
 where
     E: std::error::Error + Send,
@@ -43,7 +44,7 @@ where
     column: usize,
     snippet: String,
     kind: ErrorKind<E>,
-    previous: Option<Box<dyn std::error::Error + 'static + Send + Sync>>,
+    previous: Option<Arc<dyn std::error::Error + 'static + Send + Sync>>,
 }
 
 impl<I, E> From<InternalError<I, E>> for Error<E>
@@ -95,7 +96,7 @@ where
     where
         E2: std::error::Error + 'static + Send + Sync,
     {
-        self.previous = Some(Box::new(previous));
+        self.previous = Some(Arc::new(previous));
         self
     }
 

quil-rs/src/parser/error/internal.rs

@@ -89,7 +89,7 @@ where
 }
 
 /// A parsing error that has not been converted to something more user-friendly.
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Clone, Debug, thiserror::Error, PartialEq, Eq)]
 #[error("internal parsing error: {0:?}")]
 pub struct GenericParseError(NomErrorKind);
 

quil-rs/src/parser/error/kind.rs

@@ -15,7 +15,7 @@
 use crate::parser::error::GenericParseError;
 
 /// Kinds of errors that can occur while parsing.
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Clone, Debug, thiserror::Error, PartialEq, Eq)]
 pub enum ErrorKind<E: std::error::Error> {
     /// An internal error, i.e. one that does not have a more helpful error.
     #[error(transparent)]

quil-rs/src/parser/error/mod.rs

@@ -33,7 +33,7 @@ pub type ParseError = Error<ParserErrorKind>;
 
 /// Parsing errors specific to Quil parsing.
 #[allow(dead_code)]
-#[derive(Debug, thiserror::Error, PartialEq)]
+#[derive(Clone, Debug, thiserror::Error, PartialEq)]
 pub enum ParserErrorKind {
     /// Reached end of input, but expected something else.
     #[error("expected {0}, found EOF")]

quil-rs/src/parser/lexer/error.rs

@@ -19,7 +19,7 @@ pub(crate) type InternalLexError<'a> = InternalError<super::LexInput<'a>, LexErr
 pub type LexError = Error<LexErrorKind>;
 
 /// Kinds of errors that may occur while lexing Quil input.
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Clone, Debug, thiserror::Error, PartialEq, Eq)]
 pub enum LexErrorKind {
     /// Expected this particular raw string.
     #[error("expected {0:?}")]

quil-rs/src/program/error/leftover.rs

@@ -18,7 +18,7 @@ use std::fmt;
 /// The parser returned success, but there was unexpected leftover input.
 ///
 /// This error contains the parsed item, which can be accessed using [`LeftoverError::recover`].
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LeftoverError<O> {
     line: u32,
     column: usize,

quil-rs/src/program/error/mod.rs

@@ -28,7 +28,7 @@ pub use result::{disallow_leftover, map_parsed, recover};
 pub use syntax::SyntaxError;
 
 /// Errors that may occur while parsing a [`Program`](crate::program::Program).
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ParseProgramError<T> {
     InvalidCalibration {
         instruction: Instruction,

quil-rs/src/program/error/syntax.rs

@@ -27,7 +27,7 @@ use super::LeftoverError;
 /// see a backtrace of errors that caused this one.
 ///
 /// See also [`Error`](crate::parser::Error).
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum SyntaxError<T> {
     LexError(LexError),
     ParseError(ParseError),

quil-rs/src/program/mod.rs

@@ -45,7 +45,7 @@ mod memory;
 pub mod scheduling;
 pub mod type_check;
 
-#[derive(Debug, thiserror::Error, PartialEq)]
+#[derive(Clone, Debug, PartialEq, thiserror::Error)]
 pub enum ProgramError {
     #[error("{0}")]
     ParsingError(#[from] ParseProgramError<Program>),