chore: fix debug feature

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

Author: explodingcamera

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.
 

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(),
         }
     }

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")]

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,

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(())

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) {

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

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

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())),
         })
     }
 

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(())
     }
 }