Vendor dependencies

Let's see how I like this workflow.

vendor/wasm-bindgen/tests/wasm/slice.rs

@@ -0,0 +1,240 @@
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::Clamped;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/slice.js")]
+extern "C" {
+    fn js_export();
+
+    fn js_import();
+
+    fn js_pass_array();
+
+    fn js_export_mut();
+
+    fn js_return_vec();
+
+    fn js_clamped(val: Clamped<&[u8]>, offset: u8);
+    #[wasm_bindgen(js_name = js_clamped)]
+    fn js_clamped2(val: Clamped<Vec<u8>>, offset: u8);
+    #[wasm_bindgen(js_name = js_clamped)]
+    fn js_clamped3(val: Clamped<&mut [u8]>, offset: u8);
+}
+
+macro_rules! export_macro {
+    ($(($i:ident, $n:ident))*) => ($(
+        #[wasm_bindgen]
+        pub fn $n(a: &[$i]) -> Vec<$i> {
+            assert_eq!(a.len(), 2);
+            assert_eq!(a[0], 1 as $i);
+            assert_eq!(a[1], 2 as $i);
+            a.to_vec()
+        }
+    )*)
+}
+
+export_macro! {
+    (i8, export_i8)
+    (u8, export_u8)
+    (i16, export_i16)
+    (u16, export_u16)
+    (i32, export_i32)
+    (u32, export_u32)
+    (isize, export_isize)
+    (usize, export_usize)
+    (f32, export_f32)
+    (f64, export_f64)
+}
+
+#[wasm_bindgen_test]
+fn export() {
+    js_export();
+}
+
+macro_rules! import_macro {
+    ($(($rust:ident, $js:ident, $i:ident))*) => ($(
+        #[wasm_bindgen(module = "tests/wasm/slice.js")]
+        extern "C" {
+            fn $js(a: &[$i], b: Option<&[$i]>, c: Option<&[$i]>) -> Vec<$i>;
+        }
+
+        #[wasm_bindgen]
+        pub fn $rust(a: &[$i]) -> Vec<$i> {
+            assert_eq!(a.len(), 2);
+            assert_eq!(a[0], 1 as $i);
+            assert_eq!(a[1], 2 as $i);
+            $js(a, Some(a), None)
+        }
+    )*)
+}
+
+import_macro! {
+    (import_rust_i8, import_js_i8, i8)
+    (import_rust_u8, import_js_u8, u8)
+    (import_rust_i16, import_js_i16, i16)
+    (import_rust_u16, import_js_u16, u16)
+    (import_rust_i32, import_js_i32, i32)
+    (import_rust_u32, import_js_u32, u32)
+    (import_rust_isize, import_js_isize, isize)
+    (import_rust_usize, import_js_usize, usize)
+    (import_rust_f32, import_js_f32, f32)
+    (import_rust_f64, import_js_f64, f64)
+}
+
+#[wasm_bindgen_test]
+fn import() {
+    js_import();
+}
+
+macro_rules! pass_array_marco {
+    ($(($rust:ident, $i:ident))*) => ($(
+        #[wasm_bindgen]
+        pub fn $rust(a: &[$i]) {
+            assert_eq!(a.len(), 2);
+            assert_eq!(a[0], 1 as $i);
+            assert_eq!(a[1], 2 as $i);
+        }
+    )*)
+}
+
+pass_array_marco! {
+    (pass_array_rust_i8, i8)
+    (pass_array_rust_u8, u8)
+    (pass_array_rust_i16, i16)
+    (pass_array_rust_u16, u16)
+    (pass_array_rust_i32, i32)
+    (pass_array_rust_u32, u32)
+    (pass_array_rust_isize, isize)
+    (pass_array_rust_usize, usize)
+    (pass_array_rust_f32, f32)
+    (pass_array_rust_f64, f64)
+}
+
+#[wasm_bindgen_test]
+fn pass_array() {
+    js_pass_array();
+}
+
+macro_rules! import_mut_macro {
+    ($(($rust:ident, $js:ident, $i:ident))*) => (
+        $(
+            #[wasm_bindgen(module = "tests/wasm/slice.js")]
+            extern "C" {
+                fn $js(a: &mut [$i], b: Option<&mut [$i]>, c: Option<&mut [$i]>);
+            }
+
+            fn $rust() {
+                let mut buf1 = [
+                    1 as $i,
+                    2 as $i,
+                    3 as $i,
+                ];
+                let mut buf2 = [
+                    4 as $i,
+                    5 as $i,
+                    6 as $i,
+                ];
+                $js(&mut buf1, Some(&mut buf2), None);
+                assert_eq!(buf1[0], 4 as $i);
+                assert_eq!(buf1[1], 5 as $i);
+                assert_eq!(buf1[2], 3 as $i);
+                assert_eq!(buf2[0], 8 as $i);
+                assert_eq!(buf2[1], 7 as $i);
+                assert_eq!(buf2[2], 6 as $i);
+            }
+        )*
+
+        #[wasm_bindgen_test]
+        fn import_mut() {
+            $($rust();)*
+        }
+    )
+}
+
+import_mut_macro! {
+    (import_mut_rust_i8, import_mut_js_i8, i8)
+    (import_mut_rust_u8, import_mut_js_u8, u8)
+    (import_mut_rust_i16, import_mut_js_i16, i16)
+    (import_mut_rust_u16, import_mut_js_u16, u16)
+    (import_mut_rust_i32, import_mut_js_i32, i32)
+    (import_mut_rust_u32, import_mut_js_u32, u32)
+    (import_mut_rust_f32, import_mut_js_f32, f32)
+    (import_mut_rust_f64, import_mut_js_f64, f64)
+}
+
+macro_rules! export_mut_macro {
+    ($(($i:ident, $n:ident))*) => ($(
+        #[wasm_bindgen]
+        pub fn $n(a: &mut [$i])  {
+            assert_eq!(a.len(), 3);
+            assert_eq!(a[0], 1 as $i);
+            assert_eq!(a[1], 2 as $i);
+            assert_eq!(a[2], 3 as $i);
+            a[0] = 4 as $i;
+            a[1] = 5 as $i;
+        }
+    )*)
+}
+
+export_mut_macro! {
+    (i8, export_mut_i8)
+    (u8, export_mut_u8)
+    (i16, export_mut_i16)
+    (u16, export_mut_u16)
+    (i32, export_mut_i32)
+    (u32, export_mut_u32)
+    (isize, export_mut_isize)
+    (usize, export_mut_usize)
+    (f32, export_mut_f32)
+    (f64, export_mut_f64)
+}
+
+#[wasm_bindgen_test]
+fn export_mut() {
+    js_export_mut();
+}
+
+#[wasm_bindgen]
+pub fn return_vec_broken_vec() -> Vec<u32> {
+    vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
+}
+
+#[wasm_bindgen]
+pub fn return_vec_web_main() -> ReturnVecApplication {
+    ReturnVecApplication::new()
+}
+
+#[wasm_bindgen]
+pub struct ReturnVecApplication {
+    thing: Vec<u32>,
+}
+
+#[wasm_bindgen]
+impl ReturnVecApplication {
+    pub fn new() -> ReturnVecApplication {
+        let mut thing = vec![];
+        thing.push(0);
+        thing.push(0);
+        thing.push(0);
+        thing.push(0);
+        thing.push(0);
+
+        ReturnVecApplication { thing }
+    }
+
+    pub fn tick(&mut self) {
+        self.thing = self.thing.clone();
+    }
+}
+
+#[wasm_bindgen_test]
+fn return_vec() {
+    js_return_vec();
+}
+
+#[wasm_bindgen_test]
+fn take_clamped() {
+    js_clamped(Clamped(&[1, 2, 3]), 1);
+    js_clamped2(Clamped(vec![4, 5, 6]), 4);
+    js_clamped3(Clamped(&mut [7, 8, 9]), 7);
+}