use crate::lib::std::string::String;
#[cfg(feature = "std")]
use thiserror::Error;
#[derive(Debug)]
#[cfg_attr(feature = "std", derive(Error))]
pub enum CompileError {
#[cfg_attr(feature = "std", error("WebAssembly translation error: {0}"))]
Wasm(WasmError),
#[cfg_attr(feature = "std", error("Compilation error: {0}"))]
Codegen(String),
#[cfg_attr(feature = "std", error("Validation error: {0}"))]
Validate(String),
#[cfg_attr(feature = "std", error("Feature {0} is not yet supported"))]
UnsupportedFeature(String),
#[cfg_attr(feature = "std", error("The target {0} is not yet supported (see https://docs.wasmer.io/ecosystem/wasmer/wasmer-features)"))]
UnsupportedTarget(String),
#[cfg_attr(feature = "std", error("Insufficient resources: {0}"))]
Resource(String),
#[cfg_attr(
feature = "std",
error("cannot downcast the engine to a specific type")
)]
EngineDowncast,
}
impl From<WasmError> for CompileError {
fn from(original: WasmError) -> Self {
Self::Wasm(original)
}
}
#[derive(Debug)]
#[cfg_attr(feature = "std", derive(Error))]
#[cfg_attr(feature = "std", error("Error in middleware {name}: {message}"))]
pub struct MiddlewareError {
pub name: String,
pub message: String,
}
impl MiddlewareError {
pub fn new<A: Into<String>, B: Into<String>>(name: A, message: B) -> Self {
Self {
name: name.into(),
message: message.into(),
}
}
}
#[derive(Debug)]
#[cfg_attr(feature = "std", derive(Error))]
pub enum WasmError {
#[cfg_attr(
feature = "std",
error("Invalid input WebAssembly code at offset {offset}: {message}")
)]
InvalidWebAssembly {
message: String,
offset: usize,
},
#[cfg_attr(feature = "std", error("Unsupported feature: {0}"))]
Unsupported(String),
#[cfg_attr(feature = "std", error("Implementation limit exceeded"))]
ImplLimitExceeded,
#[cfg_attr(feature = "std", error("{0}"))]
Middleware(MiddlewareError),
#[cfg_attr(feature = "std", error("{0}"))]
Generic(String),
}
impl From<MiddlewareError> for WasmError {
fn from(original: MiddlewareError) -> Self {
Self::Middleware(original)
}
}
#[derive(Debug)]
#[cfg_attr(feature = "std", derive(Error))]
pub enum ParseCpuFeatureError {
#[cfg_attr(feature = "std", error("CpuFeature {0} not recognized"))]
Missing(String),
}
pub type WasmResult<T> = Result<T, WasmError>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn middleware_error_can_be_created() {
let msg = String::from("Something went wrong");
let error = MiddlewareError::new("manipulator3000", msg);
assert_eq!(error.name, "manipulator3000");
assert_eq!(error.message, "Something went wrong");
}
#[test]
fn middleware_error_be_converted_to_wasm_error() {
let error = WasmError::from(MiddlewareError::new("manipulator3000", "foo"));
match error {
WasmError::Middleware(MiddlewareError { name, message }) => {
assert_eq!(name, "manipulator3000");
assert_eq!(message, "foo");
}
err => panic!("Unexpected error: {:?}", err),
}
}
}