Reduce proc-macro dependencies

crates/compiler/Cargo.toml

@@ -19,9 +19,6 @@ antlr-rust = "=0.3.0-beta"
 better_any = "=0.2.0"
 regex = "1"
 yarnspinner_core = { path = "../core", version = "0.2" }
-thiserror = "1"
-strum = "0.26"
-strum_macros = "0.26"
 annotate-snippets = "0.10"
 serde = { version = "1", features = ["derive"], optional = true }
 bevy = { version = "0.13", default-features = false, optional = true }

crates/compiler/src/listeners/error_listener/diagnostic.rs

@@ -4,6 +4,7 @@ use annotate_snippets::{Annotation, AnnotationType, Renderer, Slice, Snippet, So
 use antlr_rust::rule_context::CustomRuleContext;
 use antlr_rust::token::Token;
 use antlr_rust::token_factory::TokenFactory;
+use core::fmt;
 use std::fmt::{Display, Formatter};
 use std::ops::Range;
 use yarnspinner_core::prelude::*;
@@ -184,7 +185,7 @@ impl DiagnosticVec for Vec<Diagnostic> {
 /// ## Implementation notes
 ///
 /// The `Info` variant was not implemented because it was unused.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash, strum_macros::Display)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
 #[cfg_attr(feature = "bevy", derive(Reflect))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "bevy", reflect(Debug, PartialEq, Default, Hash))]
@@ -206,3 +207,12 @@ pub enum DiagnosticSeverity {
     /// but do not cause the compilation process to fail.
     Warning,
 }
+
+impl fmt::Display for DiagnosticSeverity {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            DiagnosticSeverity::Error => f.write_str("Error"),
+            DiagnosticSeverity::Warning => f.write_str("Warning"),
+        }
+    }
+}

crates/compiler/src/output.rs

@@ -4,8 +4,8 @@ use crate::listeners::*;
 pub use crate::output::{debug_info::*, declaration::*, string_info::*};
 use crate::prelude::*;
 use std::collections::HashMap;
+use std::error::Error;
 use std::fmt::{Debug, Display};
-use thiserror::Error;
 use yarnspinner_core::prelude::*;
 
 mod debug_info;
@@ -123,7 +123,7 @@ impl Compilation {
 
 /// A collection of [`Diagnostic`] objects that describe problems that occurred during compilation.
 /// At least one of these diagnostics will have a severity of [`DiagnosticSeverity::Error`].
-#[derive(Error, Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "bevy", derive(Reflect))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "bevy", reflect(Debug, PartialEq, Hash))]
@@ -133,6 +133,8 @@ impl Compilation {
 )]
 pub struct CompilerError(pub Vec<Diagnostic>);
 
+impl Error for CompilerError {}
+
 impl Debug for CompilerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // This looks evil, but we support really nice error messages through Display,

crates/core/Cargo.toml

@@ -15,12 +15,7 @@ serde = ["dep:serde", "bevy?/serialize"]
 bevy = ["dep:bevy"]
 
 [dependencies]
-bytes = "1"
-paste = "1"
 yarnspinner_macros = { path = "../macros", version = "0.1" }
-strum = "0.26"
-strum_macros = "0.26"
-thiserror = "1"
 prost = "0.12"
 serde = { version = "1", features = ["derive"], optional = true }
 bevy = { version = "0.13", default-features = false, optional = true }

crates/core/src/generated/ext.rs

@@ -1,8 +1,8 @@
 //! Contains extensions to generated types that in the original implementation are sprinkled around the repo via partial classes
 
 use crate::prelude::*;
+use std::error::Error;
 use std::fmt::{Debug, Display};
-use thiserror::Error;
 
 impl From<String> for Operand {
     fn from(s: String) -> Self {
@@ -94,7 +94,7 @@ impl From<Operand> for YarnValue {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "bevy", derive(Reflect))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "bevy", reflect(Debug, PartialEq))]
@@ -104,6 +104,8 @@ impl From<Operand> for YarnValue {
 )]
 pub struct InvalidOpCodeError(pub i32);
 
+impl Error for InvalidOpCodeError {}
+
 impl Display for InvalidOpCodeError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{:?} is not a valid OpCode", self.0)

crates/core/src/operator.rs

@@ -1,9 +1,10 @@
 #[cfg(any(feature = "bevy", feature = "serde"))]
 use crate::prelude::*;
+use core::fmt;
 use std::borrow::Cow;
 
 /// The available operators that can be used with Yarn values.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, strum_macros::Display)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "bevy", derive(Reflect))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "bevy", reflect(Debug, PartialEq))]
@@ -83,6 +84,29 @@ pub enum Operator {
     Modulo,
 }
 
+impl fmt::Display for Operator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Operator::EqualTo => f.write_str("EqualTo"),
+            Operator::GreaterThan => f.write_str("GreaterThan"),
+            Operator::GreaterThanOrEqualTo => f.write_str("GreaterThanOrEqualTo"),
+            Operator::LessThan => f.write_str("LessThan"),
+            Operator::LessThanOrEqualTo => f.write_str("LessThanOrEqualTo"),
+            Operator::NotEqualTo => f.write_str("NotEqualTo"),
+            Operator::Or => f.write_str("Or"),
+            Operator::And => f.write_str("And"),
+            Operator::Xor => f.write_str("Xor"),
+            Operator::Not => f.write_str("Not"),
+            Operator::UnarySubtract => f.write_str("UnarySubtract"),
+            Operator::Add => f.write_str("Add"),
+            Operator::Subtract => f.write_str("Subtract"),
+            Operator::Multiply => f.write_str("Multiply"),
+            Operator::Divide => f.write_str("Divide"),
+            Operator::Modulo => f.write_str("Modulo"),
+        }
+    }
+}
+
 /// Implementing this is probably bad practice, but this greatly reduces boilerplate when used with `yarn_fn_registry!`
 impl From<Operator> for Cow<'static, str> {
     fn from(value: Operator) -> Self {

crates/core/src/types/type.rs

@@ -4,10 +4,9 @@ use crate::types::boolean::boolean_type_properties;
 use crate::types::number::number_type_properties;
 use crate::types::string::string_type_properties;
 use crate::types::*;
-use paste::paste;
 use std::any::TypeId;
+use std::error::Error;
 use std::fmt::{Debug, Display};
-use thiserror::Error;
 
 /// All types in the virtual machine, both built-in, i.e. usable in Yarn scripts, and internal.
 ///
@@ -169,33 +168,30 @@ impl TypeProperties {
 // on [`Type`] results in more compile-time safety.
 
 macro_rules! impl_type {
-    ($($yarn_type:pat => [$($base_type:path,)*] ,)*) => {
+    ($($yarn_type:expr => [$($ext:ident for $base_type:path,)*] ,)*) => {
         $(
             $(
-
-                paste! {
-                    /// Convenience trait for getting a [`Type`] out of a base type.
-                    #[allow(non_camel_case_types)]
-                    pub trait [<$base_type Ext>] {
-                        /// Get the corresponding [`Type`]
-                        fn r#type() -> Type;
-                    }
-                    impl [<$base_type Ext>] for $base_type {
-                        fn r#type() -> Type {
-                            $yarn_type
-                        }
+                /// Convenience trait for getting a [`Type`] out of a base type.
+                #[allow(non_camel_case_types)]
+                pub trait $ext {
+                    /// Get the corresponding [`Type`]
+                    fn r#type() -> Type;
+                }
+                impl $ext for $base_type {
+                    fn r#type() -> Type {
+                        $yarn_type
                     }
+                }
 
-                    impl From<&$base_type> for Type {
-                        fn from(_value: &$base_type) -> Self {
-                            $yarn_type
-                        }
+                impl From<&$base_type> for Type {
+                    fn from(_value: &$base_type) -> Self {
+                        $yarn_type
                     }
+                }
 
-                    impl From<$base_type> for Type {
-                        fn from(_value: $base_type) -> Self {
-                            $yarn_type
-                        }
+                impl From<$base_type> for Type {
+                    fn from(_value: $base_type) -> Self {
+                        $yarn_type
                     }
                 }
             )*
@@ -204,9 +200,24 @@ macro_rules! impl_type {
 }
 
 impl_type! {
-    Type::Number => [f32, f64, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize,],
-    Type::String => [String,],
-    Type::Boolean => [bool,],
+    Type::Number => [
+        f32Ext for f32,
+        f64Ext for f64,
+        i8Ext for i8,
+        i16Ext for i16,
+        i32Ext for i32,
+        i64Ext for i64,
+        i128Ext for i128,
+        u8Ext for u8,
+        u16Ext for u16,
+        u32Ext for u32,
+        u64Ext for u64,
+        u128Ext for u128,
+        usizeExt for usize,
+        isizeExt for isize,
+    ],
+    Type::String => [StringExt for String,],
+    Type::Boolean => [boolExt for bool,],
 }
 
 impl From<&str> for Type {
@@ -262,10 +273,21 @@ impl From<&YarnValue> for Type {
     }
 }
 
-#[derive(Error, Debug)]
+#[derive(Debug)]
 /// Represents a failure to dynamically convert a [`TypeId`] to a [`Type`].
 #[allow(missing_docs)]
 pub enum InvalidDowncastError {
-    #[error("Cannot convert TypeId {:?} to a Yarn Spinner `Type`", .0)]
     InvalidTypeId(TypeId),
 }
+
+impl Error for InvalidDowncastError {}
+
+impl Display for InvalidDowncastError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InvalidDowncastError::InvalidTypeId(id) => {
+                write!(f, "Cannot convert TypeId {id:?} to a Yarn Spinner `Type`")
+            }
+        }
+    }
+}

crates/core/src/yarn_value.rs

@@ -1,8 +1,8 @@
 //! Implements a subset of dotnet's [`Convert`](https://learn.microsoft.com/en-us/dotnet/api/system.convert?view=net-8.0) type.
 #[cfg(any(feature = "bevy", feature = "serde"))]
 use crate::prelude::*;
+use std::error::Error;
 use std::fmt::{Display, Formatter};
-use thiserror::Error;
 
 /// Represents a Yarn value. The chosen variant corresponds to the last assignment of the value,
 /// with the type being inferred from the type checker.
@@ -205,15 +205,50 @@ impl IntoYarnValueFromNonYarnValue for bool {
 }
 
 /// Represents a failure to convert one variant of [`YarnValue`] to a base type.
-#[derive(Error, Debug)]
+#[derive(Debug)]
 #[allow(missing_docs)]
 pub enum YarnValueCastError {
-    #[error(transparent)]
-    ParseFloatError(#[from] std::num::ParseFloatError),
-    #[error(transparent)]
-    ParseIntError(#[from] std::num::ParseIntError),
-    #[error(transparent)]
-    ParseBoolError(#[from] std::str::ParseBoolError),
+    ParseFloatError(std::num::ParseFloatError),
+    ParseIntError(std::num::ParseIntError),
+    ParseBoolError(std::str::ParseBoolError),
+}
+
+impl Error for YarnValueCastError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            YarnValueCastError::ParseFloatError(e) => Some(e),
+            YarnValueCastError::ParseIntError(e) => Some(e),
+            YarnValueCastError::ParseBoolError(e) => Some(e),
+        }
+    }
+}
+
+impl Display for YarnValueCastError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            YarnValueCastError::ParseFloatError(e) => Display::fmt(e, f),
+            YarnValueCastError::ParseIntError(e) => Display::fmt(e, f),
+            YarnValueCastError::ParseBoolError(e) => Display::fmt(e, f),
+        }
+    }
+}
+
+impl From<std::num::ParseFloatError> for YarnValueCastError {
+    fn from(value: std::num::ParseFloatError) -> Self {
+        Self::ParseFloatError(value)
+    }
+}
+
+impl From<std::num::ParseIntError> for YarnValueCastError {
+    fn from(value: std::num::ParseIntError) -> Self {
+        Self::ParseIntError(value)
+    }
+}
+
+impl From<std::str::ParseBoolError> for YarnValueCastError {
+    fn from(value: std::str::ParseBoolError) -> Self {
+        Self::ParseBoolError(value)
+    }
 }
 
 impl Display for YarnValue {

crates/runtime/Cargo.toml

@@ -29,6 +29,5 @@ icu_locid = { version = "1", features = ["std"] }
 fixed_decimal = { version = "0.5", features = ["ryu", "std"] }
 once_cell = "1"
 regex = "1"
-thiserror = "1"
 serde = { version = "1", features = ["derive"], optional = true }
 bevy = { version = "0.13", default-features = false, optional = true }