fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-07-31 20:11:55 +00:00
Code Issues Projects Releases Wiki Activity

Implement support for Uint8ClampedArray

Browse Source 
This commit implements support for binding APIs that take
`Uint8ClampedArray` in JS. This is pretty rare but comes up in a
`web-sys` binding or two, and we're now able to bind these APIs instead
of having to omit the bindings.

The `Uint8ClampedArray` type is bound by using the `Clamped` marker
struct in Rust. For example this is declaring a JS API that takes
`Uint8ClampedArray`:

    use wasm_bindgen::Clamped;

    #[wasm_bindgen]
    extern {
        fn takes_clamped(a: Clamped<&[u8]>);
    }

The `Clamped` type currently only works when wrapping the `&[u8]`, `&mut
[u8]`, and `Vec<u8>` types. Everything else will produce an error at
`wasm-bindgen` time.

Closes #421
This commit is contained in:
Alex Crichton
2018-09-24 13:49:12 -07:00
parent d10ca579e4
commit 7b495468f6
15 changed files with 169 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
crates/cli-support/src/descriptor.rs
View File

@@ -35,6 +35,7 @@ tys! {
CHAR
OPTIONAL
UNIT
CLAMPED
}
#[derive(Debug)]
@@ -63,6 +64,7 @@ pub enum Descriptor {
Char,
Option(Box<Descriptor>),
Unit,
Clamped(Box<Descriptor>),
}
#[derive(Debug)]
@@ -81,6 +83,7 @@ pub struct Closure {
pub enum VectorKind {
I8,
U8,
ClampedU8,
I16,
U16,
I32,
@@ -131,6 +134,7 @@ impl Descriptor {
}
CHAR => Descriptor::Char,
UNIT => Descriptor::Unit,
CLAMPED => Descriptor::Clamped(Box::new(Descriptor::_decode(data))),
other => panic!("unknown descriptor: {}", other),
}
}
@@ -219,6 +223,12 @@ impl Descriptor {
Descriptor::Slice(ref d) => &**d,
_ => return None,
},
Descriptor::Clamped(ref d) => {
match d.vector_kind()? {
VectorKind::U8 => return Some(VectorKind::ClampedU8),
_ => return None,
}
}
_ => return None,
};
match *inner {
@@ -268,6 +278,13 @@ impl Descriptor {
}
}
pub fn is_clamped_by_ref(&self) -> bool {
match self {
Descriptor::Clamped(d) => d.is_by_ref(),
_ => false,
}
}
pub fn is_mut_ref(&self) -> bool {
match *self {
Descriptor::RefMut(_) => true,
@@ -311,6 +328,7 @@ impl VectorKind {
VectorKind::String => "string",
VectorKind::I8 => "Int8Array",
VectorKind::U8 => "Uint8Array",
VectorKind::ClampedU8 => "Uint8ClampedArray",
VectorKind::I16 => "Int16Array",
VectorKind::U16 => "Uint16Array",
VectorKind::I32 => "Int32Array",
@@ -328,6 +346,7 @@ impl VectorKind {
VectorKind::String => 1,
VectorKind::I8 => 1,
VectorKind::U8 => 1,
VectorKind::ClampedU8 => 1,
VectorKind::I16 => 2,
VectorKind::U16 => 2,
VectorKind::I32 => 4,

2
crates/cli-support/src/js/js2rust.rs
View File

@@ -159,7 +159,7 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
i = i,
val = val,
));
if arg.is_by_ref() {
if arg.is_by_ref() || arg.is_clamped_by_ref() {
if optional {
bail!("optional slices aren't currently supported");
}

19
crates/cli-support/src/js/mod.rs
View File

@@ -1173,6 +1173,11 @@ impl<'a> Context<'a> {
self.arrayget("getArrayU8FromWasm", "getUint8Memory", 1);
}
fn expose_get_clamped_array_u8_from_wasm(&mut self) {
self.expose_clamped_uint8_memory();
self.arrayget("getClampedArrayU8FromWasm", "getUint8ClampedMemory", 1);
}
fn expose_get_array_i16_from_wasm(&mut self) {
self.expose_int16_memory();
self.arrayget("getArrayI16FromWasm", "getInt16Memory", 2);
@@ -1237,6 +1242,10 @@ impl<'a> Context<'a> {
self.memview("getUint8Memory", "Uint8Array");
}
fn expose_clamped_uint8_memory(&mut self) {
self.memview("getUint8ClampedMemory", "Uint8ClampedArray");
}
fn expose_int16_memory(&mut self) {
self.memview("getInt16Memory", "Int16Array");
}
@@ -1283,6 +1292,10 @@ impl<'a> Context<'a> {
self.expose_uint8_memory();
"getUint8Memory"
}
VectorKind::ClampedU8 => {
self.expose_clamped_uint8_memory();
"getUint8ClampedMemory"
}
VectorKind::I16 => {
self.expose_int16_memory();
"getInt16Memory"
@@ -1444,7 +1457,7 @@ impl<'a> Context<'a> {
self.expose_pass_string_to_wasm()?;
"passStringToWasm"
}
VectorKind::I8 | VectorKind::U8 => {
VectorKind::I8 | VectorKind::U8 | VectorKind::ClampedU8 => {
self.expose_pass_array8_to_wasm()?;
"passArray8ToWasm"
}
@@ -1490,6 +1503,10 @@ impl<'a> Context<'a> {
self.expose_get_array_u8_from_wasm();
"getArrayU8FromWasm"
}
VectorKind::ClampedU8 => {
self.expose_get_clamped_array_u8_from_wasm();
"getClampedArrayU8FromWasm"
}
VectorKind::I16 => {
self.expose_get_array_i16_from_wasm();
"getArrayI16FromWasm"

2
crates/cli-support/src/js/rust2js.rs
View File

@@ -112,7 +112,7 @@ impl<'a, 'b> Rust2Js<'a, 'b> {
prefix = if optional { format!("{} == 0 ? undefined : ", abi) } else { String::new() },
));
if !arg.is_by_ref() {
if !arg.is_by_ref() && !arg.is_clamped_by_ref() {
self.prelude(&format!(
"\
{start}

18
crates/webidl-tests/array.rs
View File

@@ -1,4 +1,5 @@
use js_sys::Object;
use wasm_bindgen::Clamped;
use wasm_bindgen_test::*;
include!(concat!(env!("OUT_DIR"), "/array.rs"));
@@ -9,12 +10,13 @@ fn take_and_return_a_bunch_of_slices() {
assert_eq!(f.strings("y"), "x");
assert_eq!(f.byte_strings("yz"), "xx");
assert_eq!(f.usv_strings("abc"), "efg");
assert_eq!(f.f32(&[1.0, 2.0]), [3.0, 4.0, 5.0]);
assert_eq!(f.f64(&[1.0, 2.0]), [3.0, 4.0, 5.0]);
assert_eq!(f.i8(&[1, 2]), [3, 4, 5]);
assert_eq!(f.i16(&[1, 2]), [3, 4, 5]);
assert_eq!(f.i32(&[1, 2]), [3, 4, 5]);
assert_eq!(f.u8(&[1, 2]), [3, 4, 5]);
assert_eq!(f.u16(&[1, 2]), [3, 4, 5]);
assert_eq!(f.u32(&[1, 2]), [3, 4, 5]);
assert_eq!(f.f32(&mut [1.0, 2.0]), [3.0, 4.0, 5.0]);
assert_eq!(f.f64(&mut [1.0, 2.0]), [3.0, 4.0, 5.0]);
assert_eq!(f.i8(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.i16(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.i32(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.u8(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.u16(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.u32(&mut [1, 2]), [3, 4, 5]);
assert_eq!(f.u8_clamped(Clamped(&mut [1, 2])).0, [3, 4, 5]);
}

44
crates/webidl/src/idl_type.rs
View File

@@ -1,4 +1,5 @@
use backend::util::{ident_ty, leading_colon_path_ty, raw_ident, rust_ident};
use proc_macro2::{Ident, Span};
use syn;
use weedle::common::Identifier;
use weedle::term;
@@ -501,16 +502,16 @@ impl<'a> IdlType<'a> {
IdlType::ArrayBuffer => js_sys("ArrayBuffer"),
IdlType::DataView => None,
IdlType::Int8Array => Some(array("i8", pos, false)),
IdlType::Uint8Array => Some(array("u8", pos, false)),
IdlType::Uint8ArrayMut => Some(array("u8", pos, true)),
IdlType::Uint8ClampedArray => None, // FIXME(#421)
IdlType::Int16Array => Some(array("i16", pos, false)),
IdlType::Uint16Array => Some(array("u16", pos, false)),
IdlType::Int32Array => Some(array("i32", pos, false)),
IdlType::Uint32Array => Some(array("u32", pos, false)),
IdlType::Float32Array => Some(array("f32", pos, false)),
IdlType::Float64Array => Some(array("f64", pos, false)),
IdlType::Int8Array => Some(array("i8", pos)),
IdlType::Uint8Array => Some(array("u8", pos)),
IdlType::Uint8ArrayMut => Some(array("u8", pos)),
IdlType::Uint8ClampedArray => Some(clamped(array("u8", pos))),
IdlType::Int16Array => Some(array("i16", pos)),
IdlType::Uint16Array => Some(array("u16", pos)),
IdlType::Int32Array => Some(array("i32", pos)),
IdlType::Uint32Array => Some(array("u32", pos)),
IdlType::Float32Array => Some(array("f32", pos)),
IdlType::Float64Array => Some(array("f64", pos)),
IdlType::ArrayBufferView | IdlType::BufferSource => js_sys("Object"),
IdlType::Interface(name)
@@ -709,3 +710,26 @@ fn idl_type_flatten_test() {
],
);
}
/// From `T` create `::wasm_bindgen::Clamped<T>`
fn clamped(t: syn::Type) -> syn::Type {
let arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
colon2_token: None,
lt_token: Default::default(),
args: vec![syn::GenericArgument::Type(t)].into_iter().collect(),
gt_token: Default::default(),
});
let ident = raw_ident("Clamped");
let seg = syn::PathSegment { ident, arguments };
syn::TypePath {
qself: None,
path: syn::Path {
leading_colon: Some(Default::default()),
segments: vec![
Ident::new("wasm_bindgen", Span::call_site()).into(),
seg,
].into_iter().collect(),
},
}.into()
}

2
crates/webidl/src/lib.rs
View File

@@ -156,7 +156,7 @@ fn builtin_idents() -> BTreeSet<Ident> {
vec![
"str", "char", "bool", "JsValue", "u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64",
"usize", "isize", "f32", "f64", "Result", "String", "Vec", "Option",
"Array", "ArrayBuffer", "Object", "Promise", "Function",
"Array", "ArrayBuffer", "Object", "Promise", "Function", "Clamped",
].into_iter()
.map(|id| proc_macro2::Ident::new(id, proc_macro2::Span::call_site())),
)

4
crates/webidl/src/util.rs
View File

@@ -63,10 +63,10 @@ pub fn mdn_doc(class: &str, method: Option<&str>) -> String {
}
// Array type is borrowed for arguments (`&[T]`) and owned for return value (`Vec<T>`).
pub(crate) fn array(base_ty: &str, pos: TypePosition, mutable: bool) -> syn::Type {
pub(crate) fn array(base_ty: &str, pos: TypePosition) -> syn::Type {
match pos {
TypePosition::Argument => {
shared_ref(slice_ty(ident_ty(raw_ident(base_ty))), mutable)
shared_ref(slice_ty(ident_ty(raw_ident(base_ty))), /*mutable =*/ true)
}
TypePosition::Return => {
vec_ty(ident_ty(raw_ident(base_ty)))