moved all crates into seperate folder + related path fixes

crates/repl_test/src/wasm.rs

@@ -0,0 +1,278 @@
+use std::{
+    cell::RefCell,
+    fs,
+    ops::{Deref, DerefMut},
+    path::Path,
+    sync::Mutex,
+    thread_local,
+};
+use wasmer::{
+    imports, ChainableNamedResolver, Function, ImportObject, Instance, Module, Store, Value,
+};
+use wasmer_wasi::WasiState;
+
+const WASM_REPL_COMPILER_PATH: &str = "../target/wasm32-wasi/release/roc_repl_wasm.wasm";
+
+thread_local! {
+    static REPL_STATE: RefCell<Option<ReplState>> = RefCell::new(None)
+}
+
+// The compiler Wasm instance.
+// This takes several *seconds* to initialise, so we only want to do it once for all tests.
+// Every test mutates compiler memory in `unsafe` ways, so we run them sequentially using a Mutex.
+// Even if Cargo uses many threads, these tests won't go any faster. But that's fine, they're quick.
+lazy_static! {
+    static ref COMPILER: Instance = init_compiler();
+    static ref TEST_MUTEX: Mutex<()> = Mutex::new(());
+}
+
+/// Load the compiler .wasm file and get it ready to execute
+/// THIS FUNCTION TAKES 4 SECONDS TO RUN
+fn init_compiler() -> Instance {
+    let path = Path::new(WASM_REPL_COMPILER_PATH);
+    let wasm_module_bytes = match fs::read(&path) {
+        Ok(bytes) => bytes,
+        Err(e) => panic!("{}", format_compiler_load_error(e)),
+    };
+
+    let store = Store::default();
+
+    // This is the slow line. Skipping validation checks reduces module compilation time from 5s to 4s.
+    // Safety: We trust rustc to produce a valid module.
+    let wasmer_module =
+        unsafe { Module::from_binary_unchecked(&store, &wasm_module_bytes).unwrap() };
+
+    // Specify the external functions the Wasm module needs to link to
+    // We only use WASI so that we can debug test failures more easily with println!(), dbg!(), etc.
+    let mut wasi_env = WasiState::new("compiler").finalize().unwrap();
+    let wasi_import_obj = wasi_env
+        .import_object(&wasmer_module)
+        .unwrap_or_else(|_| ImportObject::new());
+    let repl_import_obj = imports! {
+        "env" => {
+            "wasmer_create_app" => Function::new_native(&store, wasmer_create_app),
+            "wasmer_run_app" => Function::new_native(&store, wasmer_run_app),
+            "wasmer_get_result_and_memory" => Function::new_native(&store, wasmer_get_result_and_memory),
+            "wasmer_copy_input_string" => Function::new_native(&store, wasmer_copy_input_string),
+            "wasmer_copy_output_string" => Function::new_native(&store, wasmer_copy_output_string),
+            "now" => Function::new_native(&store, dummy_system_time_now),
+        }
+    };
+    // "Chain" the import objects together. Wasmer will look up the REPL object first, then the WASI object
+    let import_object = wasi_import_obj.chain_front(repl_import_obj);
+
+    // Make a fully-linked instance with its own block of memory
+    Instance::new(&wasmer_module, &import_object).unwrap()
+}
+
+struct ReplState {
+    src: &'static str,
+    app: Option<Instance>,
+    result_addr: Option<u32>,
+    output: Option<String>,
+}
+
+fn wasmer_create_app(app_bytes_ptr: u32, app_bytes_len: u32) -> u32 {
+    let app: Instance = {
+        let memory = COMPILER.exports.get_memory("memory").unwrap();
+        let memory_bytes: &[u8] = unsafe { memory.data_unchecked() };
+
+        // Find the slice of bytes for the compiled Roc app
+        let ptr = app_bytes_ptr as usize;
+        let len = app_bytes_len as usize;
+        let app_module_bytes: &[u8] = &memory_bytes[ptr..][..len];
+
+        // Parse the bytes into a Wasmer module
+        let store = Store::default();
+        let wasmer_module = match Module::new(&store, app_module_bytes) {
+            Ok(m) => m,
+            Err(e) => {
+                println!("Failed to create Wasm module\n{:?}", e);
+                if false {
+                    let path = "/tmp/roc_repl_test_invalid_app.wasm";
+                    fs::write(path, app_module_bytes).unwrap();
+                    println!("Wrote invalid wasm to {}", path);
+                }
+                return false.into();
+            }
+        };
+
+        // Get the WASI imports for the app
+        let mut wasi_env = WasiState::new("app").finalize().unwrap();
+        let import_object = wasi_env
+            .import_object(&wasmer_module)
+            .unwrap_or_else(|_| imports!());
+
+        // Create an executable instance
+        match Instance::new(&wasmer_module, &import_object) {
+            Ok(instance) => instance,
+            Err(e) => {
+                println!("Failed to create Wasm instance {:?}", e);
+                return false.into();
+            }
+        }
+    };
+
+    REPL_STATE.with(|f| {
+        if let Some(state) = f.borrow_mut().deref_mut() {
+            state.app = Some(app)
+        } else {
+            unreachable!()
+        }
+    });
+
+    return true.into();
+}
+
+fn wasmer_run_app() -> u32 {
+    REPL_STATE.with(|f| {
+        if let Some(state) = f.borrow_mut().deref_mut() {
+            if let Some(app) = &state.app {
+                let wrapper = app.exports.get_function("wrapper").unwrap();
+
+                let result_addr: i32 = match wrapper.call(&[]) {
+                    Err(e) => panic!("{:?}", e),
+                    Ok(result) => result[0].unwrap_i32(),
+                };
+                state.result_addr = Some(result_addr as u32);
+
+                let memory = app.exports.get_memory("memory").unwrap();
+                memory.size().bytes().0 as u32
+            } else {
+                unreachable!()
+            }
+        } else {
+            unreachable!()
+        }
+    })
+}
+
+fn wasmer_get_result_and_memory(buffer_alloc_addr: u32) -> u32 {
+    REPL_STATE.with(|f| {
+        if let Some(state) = f.borrow().deref() {
+            if let Some(app) = &state.app {
+                let app_memory = app.exports.get_memory("memory").unwrap();
+                let result_addr = state.result_addr.unwrap();
+
+                let app_memory_bytes: &[u8] = unsafe { app_memory.data_unchecked() };
+
+                let buf_addr = buffer_alloc_addr as usize;
+                let len = app_memory_bytes.len();
+
+                let memory = COMPILER.exports.get_memory("memory").unwrap();
+                let compiler_memory_bytes: &mut [u8] = unsafe { memory.data_unchecked_mut() };
+                compiler_memory_bytes[buf_addr..][..len].copy_from_slice(app_memory_bytes);
+
+                result_addr
+            } else {
+                panic!("REPL app not found")
+            }
+        } else {
+            panic!("REPL state not found")
+        }
+    })
+}
+
+fn wasmer_copy_input_string(src_buffer_addr: u32) {
+    let src = REPL_STATE.with(|rs| {
+        if let Some(state) = rs.borrow_mut().deref_mut() {
+            std::mem::take(&mut state.src)
+        } else {
+            unreachable!()
+        }
+    });
+
+    let memory = COMPILER.exports.get_memory("memory").unwrap();
+    let memory_bytes: &mut [u8] = unsafe { memory.data_unchecked_mut() };
+
+    let buf_addr = src_buffer_addr as usize;
+    let len = src.len();
+    memory_bytes[buf_addr..][..len].copy_from_slice(src.as_bytes());
+}
+
+fn wasmer_copy_output_string(output_ptr: u32, output_len: u32) {
+    let output: String = {
+        let memory = COMPILER.exports.get_memory("memory").unwrap();
+        let memory_bytes: &[u8] = unsafe { memory.data_unchecked() };
+
+        // Find the slice of bytes for the output string
+        let ptr = output_ptr as usize;
+        let len = output_len as usize;
+        let output_bytes: &[u8] = &memory_bytes[ptr..][..len];
+
+        // Copy it out of the Wasm module
+        let copied_bytes = output_bytes.to_vec();
+        unsafe { String::from_utf8_unchecked(copied_bytes) }
+    };
+
+    REPL_STATE.with(|f| {
+        if let Some(state) = f.borrow_mut().deref_mut() {
+            state.output = Some(output)
+        }
+    })
+}
+
+fn format_compiler_load_error(e: std::io::Error) -> String {
+    if matches!(e.kind(), std::io::ErrorKind::NotFound) {
+        format!(
+            "\n\n    {}\n\n",
+            [
+                "ROC COMPILER WASM BINARY NOT FOUND",
+                "Please run these tests using repl_test/run_wasm.sh!",
+                "It will build a .wasm binary for the compiler, and a native binary for the tests themselves",
+            ]
+            .join("\n    ")
+        )
+    } else {
+        format!("{:?}", e)
+    }
+}
+
+fn dummy_system_time_now() -> f64 {
+    0.0
+}
+
+fn run(src: &'static str) -> (bool, String) {
+    REPL_STATE.with(|rs| {
+        *rs.borrow_mut().deref_mut() = Some(ReplState {
+            src,
+            app: None,
+            result_addr: None,
+            output: None,
+        });
+    });
+
+    let ok = if let Ok(_guard) = TEST_MUTEX.lock() {
+        let entrypoint = COMPILER
+            .exports
+            .get_function("entrypoint_from_test")
+            .unwrap();
+
+        let src_len = Value::I32(src.len() as i32);
+        let wasm_ok: i32 = entrypoint.call(&[src_len]).unwrap().deref()[0].unwrap_i32();
+        wasm_ok != 0
+    } else {
+        panic!(
+            "Failed to acquire test mutex! A previous test must have panicked while holding it, running Wasm"
+        )
+    };
+
+    let final_state: ReplState = REPL_STATE.with(|rs| rs.take()).unwrap();
+    let output: String = final_state.output.unwrap();
+
+    (ok, output)
+}
+
+#[allow(dead_code)]
+pub fn expect_success(input: &'static str, expected: &str) {
+    let (ok, output) = run(input);
+    assert_eq!(ok, true);
+    assert_eq!(output, expected);
+}
+
+#[allow(dead_code)]
+pub fn expect_failure(input: &'static str, expected: &str) {
+    let (ok, output) = run(input);
+    assert_eq!(ok, false);
+    assert_eq!(output, expected);
+}