feat(core): transactions for the wasm reader

.github/pull_request_template.md

@@ -17,7 +17,6 @@ This pull request still needs...
 - [ ] Ran `cargo build`
 - [ ] Ran `cargo doc`
 - [ ] Ran `nix fmt`
-- [ ] Ran `treefmt`
 
 ### Github Issue
 

Cargo.toml

@@ -2,7 +2,7 @@
 name = "wasm-interpreter"
 version = "0.1.0"
 edition = "2021"
-rust-version = "1.74.1"
+rust-version = "1.76.0"
 description = """
 A WASM interpreter tailored for safety use-cases, such as automotive and avionics applications
 """
@@ -23,19 +23,17 @@ libm = "0.2.8"
 log = "=0.4.22"
 
 [dev-dependencies]
-test-log = {version = "0.2.14", features = ["log"]}
+test-log = { version = "0.2.14", features = ["log"] }
 env_logger = "0.10.1"
 wasmparser = "0.119.0"
 itertools = "0.12.0"
 wat = "1.0.83"
 criterion = { version = "0.5.1", features = ["html_reports"] }
 
-
 [features]
 default = ["hooks"]
 hooks = []
 
-
 [[bench]]
 name = "hook_performance_impact"
 harness = false

requirements/requirements.sdoc

@@ -172,7 +172,7 @@ RELATIONS:
 UID: REQ-17
 TITLE: Minimum Supported Rust Version (MSRV)
 STATEMENT: >>>
-The interpreter shall compile on Rust ``1.74.1`` and later versions
+The interpreter shall compile on Rust ``1.76.0`` and later versions
 <<<
 RATIONALE: >>>
 An MSRV should be clearly stated to specify which toolchain is acceptable.

src/core/reader/mod.rs

@@ -7,6 +7,7 @@ pub mod types;
 /// A struct for managing and reading WASM bytecode
 ///
 /// Its purpose is to abstract parsing basic WASM values from the bytecode.
+#[derive(Clone)]
 pub struct WasmReader<'a> {
     /// Entire WASM binary as slice
     pub full_wasm_binary: &'a [u8],
@@ -148,10 +149,39 @@ impl<'a> WasmReader<'a> {
     pub fn into_inner(self) -> &'a [u8] {
         self.full_wasm_binary
     }
+
+    /// A wrapper function for reads with transaction-like behavior.
+    ///
+    /// The provided closure will be called with `&mut self` and its result will be returned.
+    /// However if the closure returns `Err(_)`, `self` will be reset as if the closure was never called.
+    #[allow(dead_code)]
+    pub fn handle_transaction<T, E>(
+        &mut self,
+        f: impl FnOnce(&mut WasmReader<'a>) -> core::result::Result<T, E>,
+    ) -> core::result::Result<T, E> {
+        let original = self.clone();
+        f(self).inspect_err(|_| {
+            *self = original;
+        })
+    }
 }
 
 pub trait WasmReadable: Sized {
+    /// Reads a new [`Self`] from given [`WasmReader`].
+    ///
+    /// Note that if this function returns `Err(_)`, the [`WasmReader`] may still have been advanced,
+    /// which may lead to unexpected behaviour.
+    /// To avoid this consider using the [`WasmReader::handle_transaction`] method to wrap this function call.
     fn read(wasm: &mut WasmReader) -> Result<Self>;
+
+    /// Like [`read`](WasmReadable::read), but may panic
+    ///
+    /// Allows to read a [`Self`], directly returning it, instead of a [`Result`].
+    /// Useful, when prior validation already assures that a [`Self`] can be read.
+    ///
+    /// # Panics
+    ///
+    /// Panics if reading a [`Self`] fails.
     fn read_unvalidated(wasm: &mut WasmReader) -> Self;
 }
 
@@ -194,6 +224,8 @@ pub mod span {
 
 #[cfg(test)]
 mod test {
+    use crate::ValType;
+
     use super::*;
     use alloc::vec;
 
@@ -315,4 +347,38 @@ mod test {
         assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
         assert_eq!(wasm_reader.skip(6), Err(Error::Eof));
     }
+
+    #[test]
+    fn reader_transaction() {
+        let bytes = [0x1, 0x2, 0x3, 0x4, 0x5, 0x6];
+        let mut reader = WasmReader::new(&bytes);
+
+        assert_eq!(
+            reader.handle_transaction(|reader| { reader.strip_bytes::<2>() }),
+            Ok([0x1, 0x2]),
+        );
+
+        let transaction_result: Result<()> = reader.handle_transaction(|reader| {
+            assert_eq!(reader.strip_bytes::<2>(), Ok([0x3, 0x4]));
+
+            // The exact error type does not matter
+            Err(Error::InvalidMagic)
+        });
+        assert_eq!(transaction_result, Err(Error::InvalidMagic));
+
+        assert_eq!(reader.strip_bytes::<3>(), Ok([0x3, 0x4, 0x5]));
+    }
+
+    #[test]
+    fn reader_transaction_ergonomics() {
+        let bytes = [0x1, 0x2, 0x3, 0x4, 0x5, 0x6];
+        let mut reader = WasmReader::new(&bytes);
+
+        assert_eq!(reader.handle_transaction(WasmReader::read_u8), Ok(0x1));
+
+        assert_eq!(
+            reader.handle_transaction(ValType::read),
+            Err(Error::InvalidValType)
+        );
+    }
 }

treefmt.nix

@@ -2,12 +2,26 @@
 {
   # Used to find the project root
   projectRootFile = "flake.nix";
+  programs.nixpkgs-fmt.enable = true;
   programs.prettier = {
     enable = true;
+    includes = [
+      "*.css"
+      "*.html"
+      "*.js"
+      "*.json"
+      "*.json5"
+      "*.md"
+      "*.mdx"
+      "*.toml"
+      "*.yaml"
+      "*.yml"
+    ];
     settings = {
       plugins = [
         "${pkgs.nodePackages.prettier-plugin-toml}/lib/node_modules/prettier-plugin-toml/lib/index.js"
       ];
     };
   };
+  programs.rustfmt.enable = true;
 }