Implement *WasmAbi for arrays

Author: c410-f3r

crates/cli-support/src/descriptor.rs

@@ -53,6 +53,7 @@ pub enum Descriptor {
     U64,
     F32,
     F64,
+    Array,
     Boolean,
     Function(Box<Function>),
     Closure(Box<Closure>),

crates/cli-support/src/wit/incoming.rs

@@ -45,7 +45,17 @@ impl InstructionBuilder<'_, '_> {
     fn _incoming(&mut self, arg: &Descriptor) -> Result<(), Error> {
         use walrus::ValType as WasmVT;
         use wit_walrus::ValType as WitVT;
+        let vector_kind = |arg: &Descriptor| arg.vector_kind().ok_or_else(|| {
+            format_err!("unsupported argument type for calling Rust function from JS {:?}", arg)
+        });
         match arg {
+            Descriptor::Array => {
+                self.instruction(
+                    &[AdapterType::Vector(vector_kind(arg)?)],
+                    Instruction::I32FromAnyrefOwned,
+                    &[AdapterType::I32],
+                );
+            }
             Descriptor::Boolean => {
                 self.instruction(
                     &[AdapterType::Bool],
@@ -117,9 +127,7 @@ impl InstructionBuilder<'_, '_> {
             }
 
             Descriptor::Vector(_) => {
-                let kind = arg.vector_kind().ok_or_else(|| {
-                    format_err!("unsupported argument type for calling Rust function from JS {:?}", arg)
-                })?;
+                let kind = vector_kind(arg)?;
                 self.instruction(
                     &[AdapterType::Vector(kind)],
                     Instruction::VectorToMemory {

crates/cli-support/src/wit/outgoing.rs

@@ -24,7 +24,17 @@ impl InstructionBuilder<'_, '_> {
     }
 
     fn _outgoing(&mut self, arg: &Descriptor) -> Result<(), Error> {
+        let vector_kind = |arg: &Descriptor| arg.vector_kind().ok_or_else(|| {
+            format_err!("unsupported argument type for calling JS function from Rust {:?}", arg)
+        });
         match arg {
+            Descriptor::Array => {
+                self.instruction(
+                    &[AdapterType::I32],
+                    Instruction::I32FromAnyrefOwned,
+                    &[AdapterType::Vector(vector_kind(arg)?)],
+                );
+            }
             Descriptor::Boolean => {
                 self.instruction(
                     &[AdapterType::I32],
@@ -129,12 +139,7 @@ impl InstructionBuilder<'_, '_> {
             }
 
             Descriptor::Vector(_) => {
-                let kind = arg.vector_kind().ok_or_else(|| {
-                    format_err!(
-                        "unsupported argument type for calling JS function from Rust {:?}",
-                        arg
-                    )
-                })?;
+                let kind = vector_kind(arg)?;
                 let mem = self.cx.memory()?;
                 let free = self.cx.free()?;
                 self.instruction(

examples/arrays/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "arrays"
+version = "0.1.0"
+authors = ["The wasm-bindgen Developers"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+wasm-bindgen = "0.2.58"

examples/arrays/README.md

@@ -0,0 +1,15 @@
+# Working with arrays (up to 32)
+
+[View documentation for this example online][dox] or [View compiled example
+online][compiled]
+
+[compiled]: https://rustwasm.github.io/wasm-bindgen/exbuild/arrays/
+[dox]: https://rustwasm.github.io/docs/wasm-bindgen/examples/arrays.html
+
+You can build the example locally with:
+
+```
+$ npm run serve
+```
+
+and then visiting http://localhost:8080 in a browser should run the example!

examples/arrays/index.js

@@ -0,0 +1,7 @@
+const rust = import('./pkg');
+rust
+  .then(m => {
+      console.log(m.asceding_array(10));
+      console.log(m.product([1, 2, 3, 4]));
+  })
+  .catch(console.error);

examples/arrays/package.json

@@ -0,0 +1,14 @@
+{
+  "scripts": {
+    "build": "webpack",
+    "serve": "webpack-dev-server"
+  },
+  "devDependencies": {
+    "@wasm-tool/wasm-pack-plugin": "1.0.1",
+    "html-webpack-plugin": "^3.2.0",
+    "text-encoding": "^0.7.0",
+    "webpack-cli": "^3.1.1",
+    "webpack-dev-server": "^3.1.0",
+    "webpack": "^4.29.4"
+  }
+}

examples/arrays/src/lib.rs

@@ -0,0 +1,13 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn asceding_array(start: i32) -> [i32; 8] {
+    let mut array = [0; 4];
+    array.iter_mut().enumerate().for_each(|(idx, value)| *value = start + idx);
+    array
+}
+
+#[wasm_bindgen]
+pub fn product(from_js: [i32; 4]) -> i32 {
+    from_js.iter().product()
+}

examples/arrays/webpack.config.js

@@ -0,0 +1,25 @@
+const path = require('path');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+const webpack = require('webpack');
+const WasmPackPlugin = require("@wasm-tool/wasm-pack-plugin");
+
+module.exports = {
+    entry: './index.js',
+    output: {
+        path: path.resolve(__dirname, 'dist'),
+        filename: 'index.js',
+    },
+    plugins: [
+        new HtmlWebpackPlugin(),
+        new WasmPackPlugin({
+            crateDirectory: path.resolve(__dirname, ".")
+        }),
+        // Have this example work in Edge which doesn't ship `TextEncoder` or
+        // `TextDecoder` at this time.
+        new webpack.ProvidePlugin({
+          TextDecoder: ['text-encoding', 'TextDecoder'],
+          TextEncoder: ['text-encoding', 'TextEncoder']
+        })
+    ],
+    mode: 'development'
+};

src/convert/slices.rs

@@ -271,3 +271,53 @@ if_std! {
         fn is_none(slice: &WasmSlice) -> bool { slice.ptr == 0 }
     }
 }
+
+
+macro_rules! array_impls {
+    ($($N:expr),+) => {
+        $(
+            unsafe impl<T> WasmAbi for [T; $N] {}
+
+            impl<T> FromWasmAbi for [T; $N]
+            where
+                T: Copy + FromWasmAbi<Abi = [T; $N]>
+            {
+                type Abi = [T; $N];
+        
+                #[inline]
+                unsafe fn from_abi(js: Self::Abi) -> Self {
+                    use core::convert::TryInto;
+                    let slice = slice::from_raw_parts(
+                        <*const T>::from_abi(js.as_ptr() as u32),
+                        js.len(),
+                    );
+                    slice.try_into().unwrap()
+                }
+            }
+
+            impl<T> IntoWasmAbi for [T; $N]
+            where
+                T: Copy + IntoWasmAbi<Abi = [T; $N]>
+            {
+                type Abi = [T; $N];
+            
+                #[inline]
+                fn into_abi(self) -> Self::Abi {
+                    unsafe {
+                        use core::convert::TryInto;
+                        let slice = slice::from_raw_parts(
+                            self.as_ptr(),
+                            self.len()
+                        );
+                        slice.try_into().unwrap()
+                    }
+                }
+            }
+        )+
+    }
+}
+
+array_impls!(
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+    26, 27, 28, 29, 30, 31, 32
+);