chore: fix debug feature

Signed-off-by: Henry <mail@henrygressmann.de>

17 files changed, 114 insertions, 93 deletions

diff --git a/crates/parser/src/lib.rs b/crates/parser/src/lib.rs
index 73bded0..ff2cacf 100644
--- a/crates/parser/src/lib.rs
+++ b/crates/parser/src/lib.rs
@@ -3,7 +3,7 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_assignments, unused_variables))
 ))]
-#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms, unreachable_pub)]
+#![warn(missing_docs, rust_2018_idioms, unreachable_pub)]
 #![forbid(unsafe_code)]
 //! See [`tinywasm`](https://docs.rs/tinywasm) for documentation.
 
diff --git a/crates/tinywasm/src/engine.rs b/crates/tinywasm/src/engine.rs
index 8b938c5..ce84f3d 100644
--- a/crates/tinywasm/src/engine.rs
+++ b/crates/tinywasm/src/engine.rs
@@ -1,21 +1,14 @@
-use core::fmt::Debug;
-
 use alloc::sync::Arc;
 
 /// Global configuration for the WebAssembly interpreter
 ///
 /// Can be cheaply cloned and shared across multiple executions and threads.
-#[derive(Clone)]
+#[derive(Clone, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct Engine {
     pub(crate) inner: Arc<EngineInner>,
 }
 
-impl Debug for Engine {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("Engine").finish()
-    }
-}
-
 impl Engine {
     /// Create a new engine with the given configuration
     pub fn new(config: Config) -> Self {
@@ -28,15 +21,10 @@ impl Engine {
     }
 }
 
-impl Default for Engine {
-    fn default() -> Engine {
-        Engine::new(Config::default())
-    }
-}
-
+#[derive(Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct EngineInner {
     pub(crate) config: Config,
-    // pub(crate) allocator: Box<dyn Allocator + Send + Sync>,
 }
 
 /// Fuel accounting policy for budgeted execution.
@@ -51,36 +39,36 @@ pub enum FuelPolicy {
     Weighted,
 }
 
-/// Default initial size for the 32-bit value stack (i32, f32 values).
-pub const DEFAULT_VALUE_STACK_32_SIZE: usize = 64 * 1024; // 64k slots
+/// Default size for the 32-bit value stack (i32, f32 values).
+pub const DEFAULT_VALUE_STACK_32_SIZE: usize = 32 * 1024; // 32k slots
 
-/// Default initial size for the 64-bit value stack (i64, f64 values).
+/// Default size for the 64-bit value stack (i64, f64 values).
 pub const DEFAULT_VALUE_STACK_64_SIZE: usize = 32 * 1024; // 32k slots
 
-/// Default initial size for the 128-bit value stack (v128 values).
+/// Default size for the 128-bit value stack (v128 values).
 pub const DEFAULT_VALUE_STACK_128_SIZE: usize = 4 * 1024; // 4k slots
 
-/// Default initial size for the reference value stack (funcref, externref values).
+/// Default size for the reference value stack (funcref, externref values).
 pub const DEFAULT_VALUE_STACK_REF_SIZE: usize = 4 * 1024; // 4k slots
 
-/// Default initial size for the call stack (function frames).
-pub const DEFAULT_CALL_STACK_SIZE: usize = 2048; // 1024 frames
+/// Default maximum size for the call stack (function frames).
+pub const DEFAULT_MAX_CALL_STACK_SIZE: usize = 1024; // 1024 frames
 
 /// Configuration for the WebAssembly interpreter
 #[derive(Clone)]
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[non_exhaustive]
 pub struct Config {
-    /// Initial size of the 32-bit value stack (i32, f32 values).
+    /// Size of the 32-bit value stack (i32, f32 values).
     pub stack_32_size: usize,
-    /// Initial size of the 64-bit value stack (i64, f64 values).
+    /// Size of the 64-bit value stack (i64, f64 values).
     pub stack_64_size: usize,
-    /// Initial size of the 128-bit value stack (v128 values).
+    /// Size of the 128-bit value stack (v128 values).
     pub stack_128_size: usize,
-    /// Initial size of the reference value stack (funcref, externref values).
+    /// Size of the reference value stack (funcref, externref values).
     pub stack_ref_size: usize,
-    /// Initial size of the call stack.
-    pub call_stack_size: usize,
+    /// Maximum size of the call stack
+    pub max_call_stack_size: usize,
     /// Fuel accounting policy used by budgeted execution.
     pub fuel_policy: FuelPolicy,
 }
@@ -105,7 +93,7 @@ impl Default for Config {
             stack_64_size: DEFAULT_VALUE_STACK_64_SIZE,
             stack_128_size: DEFAULT_VALUE_STACK_128_SIZE,
             stack_ref_size: DEFAULT_VALUE_STACK_REF_SIZE,
-            call_stack_size: DEFAULT_CALL_STACK_SIZE,
+            max_call_stack_size: DEFAULT_MAX_CALL_STACK_SIZE,
             fuel_policy: FuelPolicy::default(),
         }
     }
diff --git a/crates/tinywasm/src/error.rs b/crates/tinywasm/src/error.rs
index 4844e48..ade5089 100644
--- a/crates/tinywasm/src/error.rs
+++ b/crates/tinywasm/src/error.rs
@@ -1,5 +1,6 @@
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
+use core::fmt::Debug;
 use core::{fmt::Display, ops::ControlFlow};
 use tinywasm_types::FuncType;
 use tinywasm_types::archive::TwasmError;
@@ -8,7 +9,6 @@ use tinywasm_types::archive::TwasmError;
 pub use tinywasm_parser::ParseError;
 
 /// Errors that can occur for `TinyWasm` operations
-#[cfg_attr(feature = "debug", derive(Debug))]
 #[non_exhaustive]
 pub enum Error {
     /// A WebAssembly trap occurred
@@ -49,9 +49,9 @@ pub enum Error {
     Twasm(TwasmError),
 }
 
-#[derive(Debug)]
 /// Errors that can occur when linking a WebAssembly module
 #[non_exhaustive]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub enum LinkingError {
     /// An unknown import was encountered
     UnknownImport {
@@ -80,11 +80,11 @@ impl LinkingError {
     }
 }
 
-#[derive(Debug)]
 /// A WebAssembly trap
 ///
 /// See <https://webassembly.github.io/spec/core/intro/overview.html#trap>
 #[non_exhaustive]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub enum Trap {
     /// An unreachable instruction was executed
     Unreachable,
@@ -206,9 +206,12 @@ impl Display for Error {
             Self::InvalidLabelType => write!(f, "invalid label type"),
             Self::Other(message) => write!(f, "unknown error: {message}"),
             Self::UnsupportedFeature(feature) => write!(f, "unsupported feature: {feature}"),
+            #[cfg(feature = "debug")]
             Self::InvalidHostFnReturn { expected, actual } => {
                 write!(f, "invalid host function return: expected={expected:?}, actual={actual:?}")
             }
+            #[cfg(not(feature = "debug"))]
+            Self::InvalidHostFnReturn { .. } => write!(f, "invalid host function return"),
             Self::InvalidStore => write!(f, "invalid store"),
         }
     }
@@ -244,13 +247,22 @@ impl Display for Trap {
             Self::UninitializedElement { index } => {
                 write!(f, "uninitialized element: index={index}")
             }
+            #[cfg(feature = "debug")]
             Self::IndirectCallTypeMismatch { expected, actual } => {
                 write!(f, "indirect call type mismatch: expected={expected:?}, actual={actual:?}")
             }
+            #[cfg(not(feature = "debug"))]
+            Self::IndirectCallTypeMismatch { .. } => write!(f, "indirect call type mismatch"),
         }
     }
 }
 
+impl Debug for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
 impl core::error::Error for Error {}
 
 #[cfg(feature = "parser")]
diff --git a/crates/tinywasm/src/func.rs b/crates/tinywasm/src/func.rs
index b75a6de..98de9a2 100644
--- a/crates/tinywasm/src/func.rs
+++ b/crates/tinywasm/src/func.rs
@@ -19,16 +19,16 @@ pub(crate) struct ExecutionState {
     pub(crate) callframe: CallFrame,
 }
 
-#[derive(Debug)]
 /// A function handle
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct FuncHandle {
     pub(crate) module_addr: ModuleInstanceAddr,
     pub(crate) addr: u32,
     pub(crate) ty: FuncType,
 }
 
-#[derive(Debug)]
 /// Resumable execution for an untyped function call.
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct FuncExecution<'store> {
     store: &'store mut Store,
     state: FuncExecutionState,
@@ -40,8 +40,8 @@ enum FuncExecutionState {
     Completed { result: Option<Vec<WasmValue>> },
 }
 
-#[derive(Debug)]
 /// Resumable execution for a typed function call.
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct FuncExecutionTyped<'store, R> {
     execution: FuncExecution<'store>,
     marker: core::marker::PhantomData<R>,
@@ -212,8 +212,8 @@ fn collect_call_results(store: &mut Store, func_ty: &FuncType) -> Result<Vec<Was
     Ok(res)
 }
 
-#[derive(Debug)]
 /// A typed function handle
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct FuncHandleTyped<P, R> {
     /// The underlying function handle
     pub func: FuncHandle,
diff --git a/crates/tinywasm/src/imports.rs b/crates/tinywasm/src/imports.rs
index fc5bf37..d55536f 100644
--- a/crates/tinywasm/src/imports.rs
+++ b/crates/tinywasm/src/imports.rs
@@ -100,13 +100,15 @@ impl FuncContext<'_> {
     }
 }
 
+#[cfg(feature = "debug")]
 impl Debug for HostFunction {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("HostFunction").field("ty", &self.ty).field("func", &"...").finish()
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[non_exhaustive]
 /// An external value
 pub enum Extern {
@@ -219,7 +221,6 @@ impl From<&Import> for ExternName {
     }
 }
 
-#[derive(Debug, Default)]
 /// Imports for a module instance
 ///
 /// This is used to link a module instance to its imports
@@ -254,7 +255,8 @@ impl From<&Import> for ExternName {
 ///
 /// Note that module instance addresses for [`Imports::link_module`] can be obtained from [`crate::ModuleInstance::id`].
 /// Now, the imports object can be passed to [`crate::ModuleInstance::instantiate`].
-#[derive(Clone)]
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct Imports {
     values: BTreeMap<ExternName, Extern>,
     modules: BTreeMap<String, ModuleInstanceAddr>,
@@ -322,9 +324,19 @@ impl Imports {
         None
     }
 
-    fn compare_types<T: Debug + PartialEq>(import: &Import, actual: &T, expected: &T) -> Result<()> {
+    #[cfg(not(feature = "debug"))]
+    fn compare_types<T: PartialEq>(import: &Import, actual: &T, expected: &T) -> Result<()> {
+        if expected != actual {
+            log::error!("failed to link import {}", import.name);
+            return Err(LinkingError::incompatible_import_type(import).into());
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "debug")]
+    fn compare_types<T: PartialEq + Debug>(import: &Import, actual: &T, expected: &T) -> Result<()> {
         if expected != actual {
-            log::error!("failed to link import {}, expected {:?}, got {:?}", import.name, expected, actual);
+            log::error!("failed to link import {}: expected {:?}, got {:?}", import.name, expected, actual);
             return Err(LinkingError::incompatible_import_type(import).into());
         }
         Ok(())
diff --git a/crates/tinywasm/src/interpreter/stack/call_stack.rs b/crates/tinywasm/src/interpreter/stack/call_stack.rs
index 4f3ace1..a91f938 100644
--- a/crates/tinywasm/src/interpreter/stack/call_stack.rs
+++ b/crates/tinywasm/src/interpreter/stack/call_stack.rs
@@ -10,7 +10,7 @@ pub(crate) struct CallStack {
 
 impl CallStack {
     pub(crate) fn new(config: &crate::engine::Config) -> Self {
-        Self { stack: Vec::with_capacity(config.call_stack_size) }
+        Self { stack: Vec::with_capacity(config.max_call_stack_size) }
     }
 
     pub(crate) fn clear(&mut self) {
diff --git a/crates/tinywasm/src/lib.rs b/crates/tinywasm/src/lib.rs
index b77dc09..cdcb1a1 100644
--- a/crates/tinywasm/src/lib.rs
+++ b/crates/tinywasm/src/lib.rs
@@ -3,7 +3,7 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_assignments, unused_variables))
 ))]
-#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms, unreachable_pub)]
+#![warn(missing_docs, rust_2018_idioms, unreachable_pub)]
 #![deny(unsafe_code)]
 
 //! A tiny WebAssembly Runtime written in Rust
diff --git a/crates/tinywasm/src/store/function.rs b/crates/tinywasm/src/store/function.rs
index ef370c2..3067a8e 100644
--- a/crates/tinywasm/src/store/function.rs
+++ b/crates/tinywasm/src/store/function.rs
@@ -2,10 +2,11 @@ use crate::Function;
 use alloc::rc::Rc;
 use tinywasm_types::*;
 
-#[derive(Debug, Clone)]
 /// A WebAssembly Function Instance
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
+#[derive(Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub(crate) struct FunctionInstance {
     pub(crate) func: Function,
     pub(crate) owner: ModuleInstanceAddr, // index into store.module_instances, none for host functions
diff --git a/crates/tinywasm/src/store/mod.rs b/crates/tinywasm/src/store/mod.rs
index 8100faf..aae8b35 100644
--- a/crates/tinywasm/src/store/mod.rs
+++ b/crates/tinywasm/src/store/mod.rs
@@ -1,6 +1,5 @@
 use alloc::rc::Rc;
 use alloc::{boxed::Box, format, string::ToString, vec::Vec};
-use core::fmt::Debug;
 use core::sync::atomic::{AtomicUsize, Ordering};
 use tinywasm_types::*;
 
@@ -40,7 +39,8 @@ pub struct Store {
     pub(crate) stack: Stack,
 }
 
-impl Debug for Store {
+#[cfg(feature = "debug")]
+impl core::fmt::Debug for Store {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Store")
             .field("id", &self.id)
@@ -323,9 +323,14 @@ impl Store {
                 })?;
                 self.state.globals[addr as usize].value.get().unwrap_ref()
             }
+            #[cfg(feature = "debug")]
             ElementItem::Expr(item) => {
                 return Err(Error::UnsupportedFeature(format!("const expression other than ref: {item:?}")));
             }
+            #[cfg(not(feature = "debug"))]
+            ElementItem::Expr(_) => {
+                return Err(Error::UnsupportedFeature("const expression other than ref".to_string()));
+            }
         };
 
         Ok(res)
@@ -467,7 +472,10 @@ impl Store {
                 TinyWasmValue::Value64(i) => i as i64,
                 other => return Err(Error::Other(format!("expected i32 or i64, got {other:?}"))),
             },
+            #[cfg(feature = "debug")]
             other => return Err(Error::Other(format!("expected i32, got {other:?}"))),
+            #[cfg(not(feature = "debug"))]
+            _ => return Err(Error::Other("expected i32 or i64".to_string())),
         })
     }
 
diff --git a/crates/tinywasm/src/store/table.rs b/crates/tinywasm/src/store/table.rs
index 627e886..7bbda83 100644
--- a/crates/tinywasm/src/store/table.rs
+++ b/crates/tinywasm/src/store/table.rs
@@ -1,4 +1,3 @@
-use crate::log;
 use crate::{Error, Result, Trap};
 use alloc::{vec, vec::Vec};
 use tinywasm_types::*;
@@ -142,9 +141,7 @@ impl TableInstance {
         if end > self.elements.len() || end < offset {
             return Err(crate::Trap::TableOutOfBounds { offset, len: init.len(), max: self.elements.len() }.into());
         }
-
         self.elements[offset..end].copy_from_slice(init);
-        log::debug!("table: {:?}", self.elements);
         Ok(())
     }
 }
diff --git a/crates/tinywasm/tests/host_func_signature_check.rs b/crates/tinywasm/tests/host_func_signature_check.rs
index 3b682b8..9b0a530 100644
--- a/crates/tinywasm/tests/host_func_signature_check.rs
+++ b/crates/tinywasm/tests/host_func_signature_check.rs
@@ -100,8 +100,7 @@ fn test_linking_invalid_typed_func() -> Result<()> {
             let mut store = Store::default();
             let mut imports = Imports::new();
             imports.define("host", "hfn", typed_fn).unwrap();
-            let link_failure = module.clone().instantiate(&mut store, Some(imports));
-            link_failure.expect_err("no func in matching_none list should link to any mod");
+            module.clone().instantiate(&mut store, Some(imports))?;
         }
     }
 
diff --git a/crates/tinywasm/tests/resume_execution.rs b/crates/tinywasm/tests/resume_execution.rs
index 0f45e20..93b1c27 100644
--- a/crates/tinywasm/tests/resume_execution.rs
+++ b/crates/tinywasm/tests/resume_execution.rs
@@ -47,7 +47,9 @@ fn untyped_resume_supports_zero_fuel() -> Result<()> {
     assert!(matches!(exec.resume_with_fuel(0)?, ExecProgress::Suspended));
 
     match exec.resume_with_fuel(16)? {
-        ExecProgress::Completed(values) => assert_eq!(values, vec![WasmValue::I32(42)]),
+        ExecProgress::Completed(values) => {
+            assert_eq!(values, vec![WasmValue::I32(42)])
+        }
         ExecProgress::Suspended => panic!("expected completion"),
     }
 
diff --git a/crates/tinywasm/tests/testsuite/mod.rs b/crates/tinywasm/tests/testsuite/mod.rs
index 2d443ba..0221c6a 100644
--- a/crates/tinywasm/tests/testsuite/mod.rs
+++ b/crates/tinywasm/tests/testsuite/mod.rs
@@ -2,6 +2,7 @@
 use eyre::{Result, eyre};
 use indexmap::IndexMap;
 use owo_colors::OwoColorize;
+use std::fmt::Display;
 use std::io::{BufRead, Seek, SeekFrom};
 use std::{
     collections::BTreeMap,
@@ -31,9 +32,9 @@ impl TestSuite {
     pub fn report_status(&self) -> Result<()> {
         if self.failed() {
             println!();
-            Err(eyre!(format!("{}:\n{:#?}", "failed one or more tests".red().bold(), self)))
+            Err(eyre!(format!("{}:\n{self}", "failed one or more tests".red().bold())))
         } else {
-            println!("\n\npassed all tests:\n{self:#?}");
+            println!("\n\npassed all tests:\n{self}");
             Ok(())
         }
     }
@@ -119,7 +120,7 @@ fn link(name: &str, file: &str, line: Option<usize>) -> String {
     format!("\x1b]8;;file://{path}\x1b\\{name}\x1b]8;;\x1b\\")
 }
 
-impl Debug for TestSuite {
+impl Display for TestSuite {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut total_passed = 0;
         let mut total_failed = 0;
@@ -145,6 +146,7 @@ impl Debug for TestSuite {
     }
 }
 
+#[derive(Debug)]
 struct TestGroup {
     tests: IndexMap<String, TestCase>,
     file: String,
diff --git a/crates/types/src/archive.rs b/crates/types/src/archive.rs
index 069addf..dc98e30 100644
--- a/crates/types/src/archive.rs
+++ b/crates/types/src/archive.rs
@@ -4,10 +4,10 @@ use alloc::vec::Vec;
 
 use crate::TinyWasmModule;
 
-const TWASM_MAGIC_PREFIX: &[u8; 4] = b"TWAS";
-const TWASM_VERSION: &[u8; 2] = b"03";
 #[rustfmt::skip]
 const TWASM_MAGIC: [u8; 16] = [ TWASM_MAGIC_PREFIX[0], TWASM_MAGIC_PREFIX[1], TWASM_MAGIC_PREFIX[2], TWASM_MAGIC_PREFIX[3], TWASM_VERSION[0], TWASM_VERSION[1], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+const TWASM_MAGIC_PREFIX: &[u8; 4] = b"TWAS";
+const TWASM_VERSION: &[u8; 2] = b"03";
 
 fn validate_magic(wasm: &[u8]) -> Result<usize, TwasmError> {
     if wasm.len() < TWASM_MAGIC.len() || &wasm[..TWASM_MAGIC_PREFIX.len()] != TWASM_MAGIC_PREFIX {
@@ -66,14 +66,6 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_serialize() {
-        let wasm = TinyWasmModule::default();
-        let twasm = wasm.serialize_twasm().expect("should serialize");
-        let wasm2 = TinyWasmModule::from_twasm(&twasm).unwrap();
-        assert_eq!(wasm, wasm2);
-    }
-
-    #[test]
     fn test_invalid_magic() {
         let wasm = TinyWasmModule::default();
         let mut twasm = wasm.serialize_twasm().expect("should serialize");
diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs
index 1165c06..83d0da8 100644
--- a/crates/types/src/instructions.rs
+++ b/crates/types/src/instructions.rs
@@ -48,10 +48,10 @@ pub enum ConstInstruction {
 /// Wasm Bytecode can map to multiple of these instructions.
 ///
 /// See <https://webassembly.github.io/spec/core/binary/instructions.html>
+#[rustfmt::skip]
 #[derive(Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
-#[rustfmt::skip]
 pub enum Instruction {
     LocalCopy32(LocalAddr, LocalAddr), LocalCopy64(LocalAddr, LocalAddr), LocalCopy128(LocalAddr, LocalAddr), LocalCopyRef(LocalAddr, LocalAddr),
     I32AddLocals(LocalAddr, LocalAddr), I64AddLocals(LocalAddr, LocalAddr),
diff --git a/crates/types/src/lib.rs b/crates/types/src/lib.rs
index 78b83d0..8a815cb 100644
--- a/crates/types/src/lib.rs
+++ b/crates/types/src/lib.rs
@@ -2,9 +2,9 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_assignments, unused_variables))
 ))]
-#![warn(missing_debug_implementations, rust_2018_idioms, unreachable_pub)]
+#![warn(rust_2018_idioms, unreachable_pub)]
 #![no_std]
-#![forbid(unsafe_code)]
+#![deny(unsafe_code)]
 
 //! Types used by [`tinywasm`](https://docs.rs/tinywasm) and [`tinywasm_parser`](https://docs.rs/tinywasm_parser).
 
@@ -50,7 +50,7 @@ pub mod archive;
 
 #[cfg(not(feature = "archive"))]
 pub mod archive {
-    #[derive(Debug)]
+    #[cfg_attr(feature = "debug", derive(Debug))]
     pub enum TwasmError {}
     impl core::fmt::Display for TwasmError {
         fn fmt(&self, _: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -272,6 +272,12 @@ pub struct WasmFunction {
 // wrapper around Arc<[T]> to support serde serialization and deserialization
 pub struct ArcSlice<T>(pub Arc<[T]>);
 
+impl<T: Debug> Debug for ArcSlice<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.0.as_ref().fmt(f)
+    }
+}
+
 impl<T> From<alloc::vec::Vec<T>> for ArcSlice<T> {
     fn from(vec: alloc::vec::Vec<T>) -> Self {
         Self(Arc::from(vec))
@@ -292,21 +298,15 @@ impl<T> Deref for ArcSlice<T> {
     }
 }
 
-impl<T: Debug> Debug for ArcSlice<T> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.0.as_ref().fmt(f)
-    }
-}
-
 #[cfg(feature = "archive")]
-impl<T: serde::Serialize + Debug> serde::Serialize for ArcSlice<T> {
+impl<T: serde::Serialize> serde::Serialize for ArcSlice<T> {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.0.as_ref().serialize(serializer)
     }
 }
 
 #[cfg(feature = "archive")]
-impl<'de, T: serde::Deserialize<'de> + Debug> serde::Deserialize<'de> for ArcSlice<T> {
+impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for ArcSlice<T> {
     fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let vec: alloc::vec::Vec<T> = alloc::vec::Vec::deserialize(deserializer)?;
         Ok(Self(Arc::from(vec)))
diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs
index afaa0d3..8cc7f1b 100644
--- a/crates/types/src/value.rs
+++ b/crates/types/src/value.rs
@@ -23,12 +23,33 @@ pub enum WasmValue {
     RefFunc(FuncRef),
 }
 
+impl Debug for WasmValue {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::I32(i) => write!(f, "i32({i})"),
+            Self::I64(i) => write!(f, "i64({i})"),
+            Self::F32(i) => write!(f, "f32({i})"),
+            Self::F64(i) => write!(f, "f64({i})"),
+            Self::V128(i) => write!(f, "v128({i:?})"),
+            #[cfg(feature = "debug")]
+            Self::RefExtern(i) => write!(f, "ref({i:?})"),
+            #[cfg(feature = "debug")]
+            Self::RefFunc(i) => write!(f, "func({i:?})"),
+            #[cfg(not(feature = "debug"))]
+            Self::RefExtern(_) => write!(f, "ref()"),
+            #[cfg(not(feature = "debug"))]
+            Self::RefFunc(_) => write!(f, "func()"),
+        }
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct ExternRef(Option<ExternAddr>);
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct FuncRef(Option<FuncAddr>);
 
+#[cfg(feature = "debug")]
 impl Debug for ExternRef {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self.0 {
@@ -38,6 +59,7 @@ impl Debug for ExternRef {
     }
 }
 
+#[cfg(feature = "debug")]
 impl Debug for FuncRef {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self.0 {
@@ -268,20 +290,6 @@ impl WasmValue {
     }
 }
 
-impl Debug for WasmValue {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::I32(i) => write!(f, "i32({i})"),
-            Self::I64(i) => write!(f, "i64({i})"),
-            Self::F32(i) => write!(f, "f32({i})"),
-            Self::F64(i) => write!(f, "f64({i})"),
-            Self::V128(i) => write!(f, "v128({i:?})"),
-            Self::RefExtern(i) => write!(f, "ref({i:?})"),
-            Self::RefFunc(i) => write!(f, "func({i:?})"),
-        }
-    }
-}
-
 impl WasmValue {
     /// Get the type of a [`WasmValue`]
     #[inline]