Remove unused wasm functions

RoyalIcing · RoyalIcing · commit 9d4ebf0c6a8f · 2023-02-27T13:08:30.000+11:00
diff --git a/lib/components_guide/rustler/math.ex b/lib/components_guide/rustler/math.ex
@@ -21,18 +21,12 @@ defmodule ComponentsGuide.Rustler.Math do
   def reverse_string(_), do: error()
   def wasm_example_n_i32(_, _, _), do: error()
   def wasm_example_0(_, _), do: error()
-  def wasm_example_1_i32(_, _, _), do: error()
-  def wasm_example_2_i32(_, _, _, _), do: error()
-  def wasm_buffer_2_i32(_, _, _, _), do: error()
   def wasm_string_2_i32(_, _, _, _), do: error()
 
   def wasm_example(source, f), do: wasm_example_0(source, f)
   def wasm_example(source, f, a), do: wasm_example_n_i32(source, f, [a]) |> process_result()
   def wasm_example(source, f, a, b), do: wasm_example_n_i32(source, f, [a, b]) |> process_result()
 
-  def wasm_buffer(source, f, a, b) do
-    wasm_buffer_2_i32(source, f, a, b) |> process_result()
-  end
   def wasm_string(source, f, a, b), do: wasm_string_2_i32(source, f, a, b)
 
   defp error, do: :erlang.nif_error(:nif_not_loaded)
diff --git a/native/componentsguide_rustler_math/src/lib.rs b/native/componentsguide_rustler_math/src/lib.rs
@@ -18,7 +18,7 @@ fn reverse_string(a: String) -> String {
 fn wasm_example_n_i32(source: String, f: String, args: Vec<i32>) -> Result<Vec<i32>, Error> {
     // return Ok(5);
     //return Err(Error::Term(Box::new("hello")));
-    return match wasm_example_n_i32_internal(source, false, f, args) {
+    return match wasm_example_n_i32_internal(source, true, f, args) {
       Ok(v) => Ok(v),
       Err(e) => Err(Error::Term(Box::new(e.to_string())))
     }
@@ -71,67 +71,6 @@ fn wasm_example_0_internal(source: String, f: String) -> Result<i32, anyhow::Err
     return Ok(result);
 }
 
-#[rustler::nif]
-fn wasm_example_1_i32(source: String, f: String, a: i32) -> Result<i32, Error> {
-    return match wasm_example_1_i32_internal(source, f, a) {
-      Ok(v) => Ok(v),
-      Err(e) => Err(Error::Term(Box::new(e.to_string())))
-    }
-}
-
-fn wasm_example_1_i32_internal(source: String, f: String, a: i32) -> Result<i32, anyhow::Error> {
-    let engine = Engine::default();
-
-    // We start off by creating a `Module` which represents a compiled form
-    // of our input wasm module. In this case it'll be JIT-compiled after
-    // we parse the text format.
-    let module = Module::new(&engine, source)?;
-
-    // A `Store` is what will own instances, functions, globals, etc. All wasm
-    // items are stored within a `Store`, and it's what we'll always be using to
-    // interact with the wasm world. Custom data can be stored in stores but for
-    // now we just use `()`.
-    let mut store = Store::new(&engine, ());
-
-    // With a compiled `Module` we can then instantiate it, creating
-    // an `Instance` which we can actually poke at functions on.
-    let instance = Instance::new(&mut store, &module, &[])?;
-
-    // The `Instance` gives us access to various exported functions and items,
-    // which we access here to pull out our `answer` exported function and
-    // run it.
-    let answer = instance
-        .get_func(&mut store, &f)
-        .expect(&format!("{} was not an exported function", f));
-
-    // There's a few ways we can call the `answer` `Func` value. The easiest
-    // is to statically assert its signature with `typed` (in this case
-    // asserting it takes no arguments and returns one i32) and then call it.
-    let answer = answer.typed::<i32, i32>(&store)?;
-
-    // And finally we can call our function! Note that the error propagation
-    // with `?` is done to handle the case where the wasm function traps.
-    let result = answer.call(&mut store, a)?;
-
-    return Ok(result);
-}
-
-#[rustler::nif]
-fn wasm_example_2_i32(source: String, f: String, a: i32, b: i32) -> Result<i32, Error> {
-    return match wasm_example_2_i32_internal(source, false, f, a, b) {
-      Ok(v) => Ok(v),
-      Err(e) => Err(Error::Term(Box::new(e.to_string())))
-    }
-}
-
-#[rustler::nif]
-fn wasm_buffer_2_i32(wat_source: String, f: String, a: i32, b: i32) -> Result<Vec<i32>, Error> {
-    return match wasm_example_2_i32_n_internal(wat_source, true, f, a, b) {
-      Ok(v) => Ok(v),
-      Err(e) => Err(Error::Term(Box::new(e.to_string())))
-    }
-}
-
 #[rustler::nif]
 fn wasm_string_2_i32(wat_source: String, f: String, a: i32, b: i32) -> Result<String, Error> {
     return match wasm_example_2_i32_string_internal(wat_source, f, a, b) {
@@ -140,107 +79,6 @@ fn wasm_string_2_i32(wat_source: String, f: String, a: i32, b: i32) -> Result<St
     }
 }
 
-fn wasm_example_2_i32_internal(wat_source: String, buffer: bool, f: String, a: i32, b: i32) -> Result<i32, anyhow::Error> {
-    let engine = Engine::default();
-
-    // A `Store` is what will own instances, functions, globals, etc. All wasm
-    // items are stored within a `Store`, and it's what we'll always be using to
-    // interact with the wasm world. Custom data can be stored in stores but for
-    // now we just use `()`.
-    let mut store = Store::new(&engine, ());
-    let mut linker = Linker::new(&engine);
-
-    if buffer {
-      let memory_ty = MemoryType::new(1, None);
-      let memory = Memory::new(&mut store, memory_ty)?;
-      linker.define(&store, "env", "buffer", memory)?;
-    }
-
-    // We start off by creating a `Module` which represents a compiled form
-    // of our input wasm module. In this case it'll be JIT-compiled after
-    // we parse the text format.
-    let module = Module::new(&engine, wat_source)?;
-    
-    // With a compiled `Module` we can then instantiate it, creating
-    // an `Instance` which we can actually poke at functions on.
-    // let instance = Instance::new(&mut store, &module, &[])?;
-    let instance = linker.instantiate(&mut store, &module)?;
-
-    // The `Instance` gives us access to various exported functions and items,
-    // which we access here to pull out our `answer` exported function and
-    // run it.
-    let answer = instance
-        .get_func(&mut store, &f)
-        .expect(&format!("{} was not an exported function", f));
-
-    // There's a few ways we can call the `answer` `Func` value. The easiest
-    // is to statically assert its signature with `typed` (in this case
-    // asserting it takes no arguments and returns one i32) and then call it.
-    let answer = answer.typed::<(i32, i32), i32>(&store)?;
-
-    // And finally we can call our function! Note that the error propagation
-    // with `?` is done to handle the case where the wasm function traps.
-    let result = answer.call(&mut store, (a, b))?;
-
-    return Ok(result);
-}
-
-fn wasm_example_2_i32_n_internal(wat_source: String, buffer: bool, f: String, a: i32, b: i32) -> Result<Vec<i32>, anyhow::Error> {
-    let engine = Engine::default();
-
-    // A `Store` is what will own instances, functions, globals, etc. All wasm
-    // items are stored within a `Store`, and it's what we'll always be using to
-    // interact with the wasm world. Custom data can be stored in stores but for
-    // now we just use `()`.
-    let mut store = Store::new(&engine, ());
-    let mut linker = Linker::new(&engine);
-
-    if buffer {
-      let memory_ty = MemoryType::new(1, None);
-      let memory = Memory::new(&mut store, memory_ty)?;
-      linker.define(&store, "env", "buffer", memory)?;
-    }
-
-    // We start off by creating a `Module` which represents a compiled form
-    // of our input wasm module. In this case it'll be JIT-compiled after
-    // we parse the text format.
-    let module = Module::new(&engine, wat_source)?;
-    
-    // With a compiled `Module` we can then instantiate it, creating
-    // an `Instance` which we can actually poke at functions on.
-    // let instance = Instance::new(&mut store, &module, &[])?;
-    let instance = linker.instantiate(&mut store, &module)?;
-
-    // The `Instance` gives us access to various exported functions and items,
-    // which we access here to pull out our `answer` exported function and
-    // run it.
-    let answer = instance
-        .get_func(&mut store, &f)
-        .expect(&format!("{} was not an exported function", f));
-
-    let func_type = answer.ty(&store);
-    // There's a few ways we can call the `answer` `Func` value. The easiest
-    // is to statically assert its signature with `typed` (in this case
-    // asserting it takes no arguments and returns one i32) and then call it.
-    // let answer = answer.typed::<(i32, i32), i32>(&store)?;
-
-    // let args = vec![a, b];
-    let args: &[Val] = &[Val::I32(a), Val::I32(b)];
-
-    let mut result: Vec<Val> = Vec::with_capacity(16);
-    // result.resize(2, Val::I32(0));
-    let result_length = func_type.results().len();
-    result.resize(result_length, Val::I32(0));
-
-    // And finally we can call our function! Note that the error propagation
-    // with `?` is done to handle the case where the wasm function traps.
-    answer.call(&mut store, &args, &mut result)?;
-
-    let result: Vec<_> = result.iter().map(|v| v.unwrap_i32()).collect();
-
-    return Ok(result);
-}
-
 fn wasm_example_2_i32_string_internal(wat_source: String, f: String, a: i32, b: i32) -> Result<String, anyhow::Error> {
   let engine = Engine::default();
 
@@ -354,8 +192,5 @@ rustler::init!("Elixir.ComponentsGuide.Rustler.Math", [
   reverse_string,
   wasm_example_n_i32,
   wasm_example_0,
-  wasm_example_1_i32,
-  wasm_example_2_i32,
-  wasm_buffer_2_i32,
   wasm_string_2_i32
 ]);
diff --git a/test/components_guide/rustler/math_test.exs b/test/components_guide/rustler/math_test.exs
@@ -51,7 +51,6 @@ defmodule ComponentsGuide.Rustler.MathTest do
     """
 
     assert Math.wasm_example(wasm_source, "add", 7, 5) == 12
-    assert Math.wasm_buffer(wasm_source, "add", 7, 5) == 12
   end
 
   test "wasm_example/4 multiplying two numbers" do
@@ -108,7 +107,7 @@ defmodule ComponentsGuide.Rustler.MathTest do
     )
     """
 
-    assert Math.wasm_buffer(wasm_source, "main", 0, 0) == {256, 30}
+    assert Math.wasm_example(wasm_source, "main", 0, 0) == {256, 30}
     assert Math.wasm_string(wasm_source, "main", 0, 0) == "Know the length of this string"
   end
 
