fix: compilation error introduced in previous commit.

Author: plusvic

lib/src/compiler/errors.rs

@@ -62,7 +62,7 @@ pub enum SerializationError {
 
     /// Error occurred while deserializing WASM code.
     #[error("invalid YARA-X compiled rules file")]
-    InvalidWASM(#[from] wasmtime::Error),
+    InvalidWASM(#[from] anyhow::Error),
 }
 
 /// Error returned when rule compilation fails.
@@ -652,7 +652,7 @@ pub struct InvalidModifier {
 #[associated_enum(CompileError)]
 #[error(code = "E034", title = "potentially slow loop")]
 #[label(
-"this range can be very large",
+    "this range can be very large",
     loc
 )]
 pub struct PotentiallySlowLoop {

lib/src/compiler/rules.rs

@@ -6,6 +6,7 @@ use std::slice::Iter;
 use std::time::Instant;
 
 use aho_corasick::AhoCorasick;
+use anyhow::anyhow;
 #[cfg(feature = "logging")]
 use log::*;
 use regex_automata::meta::Regex;
@@ -225,11 +226,13 @@ impl Rules {
             #[cfg(feature = "logging")]
             let start = Instant::now();
 
-            rules.compiled_wasm_mod =
-                Some(wasm::runtime::Module::from_binary(
+            rules.compiled_wasm_mod = Some(
+                wasm::runtime::Module::from_binary(
                     wasm::get_engine(),
                     rules.wasm_mod.as_slice(),
-                )?);
+                )
+                .map_err(|e| SerializationError::from(anyhow!(e)))?,
+            );
 
             #[cfg(feature = "logging")]
             info!("WASM build time: {:?}", Instant::elapsed(&start));

lib/src/wasm/mod.rs

@@ -99,8 +99,8 @@ use crate::types::{
 };
 use crate::wasm::integer::RangedInteger;
 use crate::wasm::runtime::{
-    AsContext, AsContextMut, Caller, Config, Engine, FuncType, Linker, ValRaw,
-    ValType,
+    AsContext, AsContextMut, Caller, Config, Engine, FuncType, Linker,
+    Trampoline, TrampolineResult, ValRaw, ValType,
 };
 use crate::wasm::string::RuntimeString;
 use crate::wasm::string::String as _;
@@ -279,7 +279,7 @@ impl WasmExport {
 pub(crate) trait WasmExportedFn {
     /// Returns the function that will be passed to the selected runtime linker
     /// while linking the WASM code to this function.
-    fn trampoline(&'static self) -> TrampolineFn;
+    fn trampoline(&'static self) -> Trampoline<ScanContext<'static, 'static>>;
 
     /// Returns a [`Vec<ValType>`] with the types of the function's
     /// arguments
@@ -302,13 +302,6 @@ pub(crate) trait WasmExportedFn {
     }
 }
 
-type TrampolineFn = Box<
-    dyn Fn(Caller<'_, ScanContext>, &mut [ValRaw]) -> wasmtime::Result<()>
-        + Send
-        + Sync
-        + 'static,
->;
-
 const MAX_RESULTS: usize = 4;
 type WasmResultArray<T> = SmallVec<[T; MAX_RESULTS]>;
 
@@ -689,11 +682,11 @@ macro_rules! impl_wasm_exported_fn {
             #[allow(unused_variables)]
             #[allow(non_snake_case)]
             #[allow(unused_mut)]
-            fn trampoline(&'static self) -> TrampolineFn {
+            fn trampoline(&'static self) -> Trampoline<ScanContext<'static, 'static>> {
                 Box::new(
                     |mut caller: Caller<'_, ScanContext>,
                      args_and_results: &mut [ValRaw]|
-                     -> wasmtime::Result<()> {
+                     -> TrampolineResult {
                         let mut i = 0;
                         $(
                             let $args = args_and_results[i].raw_into(caller.data_mut());
@@ -708,7 +701,7 @@ macro_rules! impl_wasm_exported_fn {
 
                         args_and_results[0..num_results].clone_from_slice(result_slice);
 
-                        wasmtime::Result::Ok(())
+                        TrampolineResult::Ok(())
                     },
                 )
             }

lib/src/wasm/runtime/browser.rs

@@ -40,6 +40,9 @@ pub(crate) use super::common::{
     ValType,
 };
 
+pub(crate) type Trampoline<T> = common::Trampoline<T, Backend>;
+pub(crate) type TrampolineResult = common::TrampolineResult;
+
 struct GlobalInner {
     val_type: ValType,
     mutability: Mutability,

lib/src/wasm/runtime/common.rs

@@ -529,6 +529,15 @@ pub(crate) struct Linker<T, B: RuntimeBackend> {
     _phantom: PhantomData<T>,
 }
 
+pub(crate) type Trampoline<T, B> = Box<
+    dyn Fn(Caller<'_, T, B>, &mut [ValRaw]) -> TrampolineResult
+        + Send
+        + Sync
+        + 'static,
+>;
+
+pub(crate) type TrampolineResult = Result<()>;
+
 impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
     /// Creates an empty linker.
     ///
@@ -552,13 +561,8 @@ impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
         name: &str,
         ty: FuncType,
         sync_flags: u32,
-        trampoline: Box<
-            dyn Fn(Caller<'_, T, B>, &mut [ValRaw]) -> Result<()>
-                + Send
-                + Sync
-                + 'static,
-        >,
-    ) -> Result<()> {
+        trampoline: Trampoline<T, B>,
+    ) -> TrampolineResult {
         // This mirrors Wasmtime's unchecked registration API. The generated
         // WASM determines the ABI, so the runtime only needs to record the
         // metadata and trampoline here.
@@ -571,7 +575,8 @@ impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
             sync_flags,
             trampoline: Arc::from(trampoline),
         });
-        Ok(())
+
+        TrampolineResult::Ok(())
     }
 
     /// Defines an extern import.

lib/src/wasm/runtime/native.rs

@@ -3,8 +3,9 @@
 //! This adapter exists only to normalize a couple of APIs so the rest of the
 //! crate can talk to native and custom runtimes through the same interface.
 
+use crate::errors::SerializationError;
+use anyhow::anyhow;
 use std::mem::transmute;
-
 /// Wasmtime types re-exported by the native runtime.
 pub(crate) use wasmtime::{
     AsContext, AsContextMut, Caller, Config, Engine, Extern, FuncType, Global,
@@ -15,10 +16,14 @@ pub(crate) use wasmtime::{
 /// Thin wrapper around [`wasmtime::Linker`] with a backend-neutral API.
 pub(crate) struct Linker<T>(wasmtime::Linker<T>);
 
-type Trampoline<T> = dyn Fn(Caller<'_, T>, &mut [ValRaw]) -> wasmtime::Result<()>
-    + Send
-    + Sync
-    + 'static;
+pub(crate) type Trampoline<T> = Box<
+    dyn Fn(Caller<'_, T>, &mut [ValRaw]) -> TrampolineResult
+        + Send
+        + Sync
+        + 'static,
+>;
+
+pub(crate) type TrampolineResult = wasmtime::Result<()>;
 
 impl<T: 'static> Linker<T> {
     /// Creates a new linker.
@@ -37,8 +42,8 @@ impl<T: 'static> Linker<T> {
         name: &str,
         ty: FuncType,
         sync_flags: u32,
-        trampoline: Box<Trampoline<T>>,
-    ) -> wasmtime::Result<()> {
+        trampoline: Trampoline<T>,
+    ) -> TrampolineResult {
         let _ = sync_flags;
         unsafe {
             self.0
@@ -72,7 +77,9 @@ impl<T: 'static> Linker<T> {
         &self,
         store: impl AsContextMut<Data = T>,
         module: &Module,
-    ) -> wasmtime::Result<Instance> {
-        self.0.instantiate(store, module)
+    ) -> Result<Instance, SerializationError> {
+        self.0
+            .instantiate(store, module)
+            .map_err(|e| SerializationError::InvalidWASM(anyhow!(e)))
     }
 }