From 7e5d7eea9c580ef4b41a765bde624af431942b96 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 4 May 2024 14:41:35 +0200 Subject: Merging upstream version 1.70.0+dfsg2. Signed-off-by: Daniel Baumann --- vendor/wasm-bindgen/src/cache/intern.rs | 103 ++ vendor/wasm-bindgen/src/cache/mod.rs | 1 + vendor/wasm-bindgen/src/cast.rs | 160 +++ vendor/wasm-bindgen/src/closure.rs | 885 +++++++++++++ vendor/wasm-bindgen/src/convert/closures.rs | 225 ++++ vendor/wasm-bindgen/src/convert/impls.rs | 378 ++++++ vendor/wasm-bindgen/src/convert/mod.rs | 11 + vendor/wasm-bindgen/src/convert/slices.rs | 311 +++++ vendor/wasm-bindgen/src/convert/traits.rs | 131 ++ vendor/wasm-bindgen/src/describe.rs | 192 +++ vendor/wasm-bindgen/src/externref.rs | 184 +++ vendor/wasm-bindgen/src/lib.rs | 1800 +++++++++++++++++++++++++++ 12 files changed, 4381 insertions(+) create mode 100644 vendor/wasm-bindgen/src/cache/intern.rs create mode 100644 vendor/wasm-bindgen/src/cache/mod.rs create mode 100644 vendor/wasm-bindgen/src/cast.rs create mode 100644 vendor/wasm-bindgen/src/closure.rs create mode 100644 vendor/wasm-bindgen/src/convert/closures.rs create mode 100644 vendor/wasm-bindgen/src/convert/impls.rs create mode 100644 vendor/wasm-bindgen/src/convert/mod.rs create mode 100644 vendor/wasm-bindgen/src/convert/slices.rs create mode 100644 vendor/wasm-bindgen/src/convert/traits.rs create mode 100644 vendor/wasm-bindgen/src/describe.rs create mode 100644 vendor/wasm-bindgen/src/externref.rs create mode 100644 vendor/wasm-bindgen/src/lib.rs (limited to 'vendor/wasm-bindgen/src') diff --git a/vendor/wasm-bindgen/src/cache/intern.rs b/vendor/wasm-bindgen/src/cache/intern.rs new file mode 100644 index 000000000..c8aa51b2c --- /dev/null +++ b/vendor/wasm-bindgen/src/cache/intern.rs @@ -0,0 +1,103 @@ +use cfg_if::cfg_if; + + +cfg_if! { + if #[cfg(feature = "enable-interning")] { + use std::thread_local; + use std::string::String; + use std::borrow::ToOwned; + use std::cell::RefCell; + use std::collections::HashMap; + use crate::JsValue; + + struct Cache { + entries: RefCell>, + } + + thread_local! { + static CACHE: Cache = Cache { + entries: RefCell::new(HashMap::new()), + }; + } + + /// This returns the raw index of the cached JsValue, so you must take care + /// so that you don't use it after it is freed. + pub(crate) fn unsafe_get_str(s: &str) -> Option { + CACHE.with(|cache| { + let cache = cache.entries.borrow(); + + cache.get(s).map(|x| x.idx) + }) + } + + fn intern_str(key: &str) { + CACHE.with(|cache| { + let mut cache = cache.entries.borrow_mut(); + + // Can't use `entry` because `entry` requires a `String` + if !cache.contains_key(key) { + cache.insert(key.to_owned(), JsValue::from(key)); + } + }) + } + + fn unintern_str(key: &str) { + CACHE.with(|cache| { + let mut cache = cache.entries.borrow_mut(); + + cache.remove(key); + }) + } + } +} + + +/// Interns Rust strings so that it's much faster to send them to JS. +/// +/// Sending strings from Rust to JS is slow, because it has to do a full `O(n)` +/// copy and *also* encode from UTF-8 to UTF-16. This must be done every single +/// time a string is sent to JS. +/// +/// If you are sending the same string multiple times, you can call this `intern` +/// function, which simply returns its argument unchanged: +/// +/// ```rust +/// # use wasm_bindgen::intern; +/// intern("foo") // returns "foo" +/// # ; +/// ``` +/// +/// However, if you enable the `"enable-interning"` feature for wasm-bindgen, +/// then it will add the string into an internal cache. +/// +/// When you send that cached string to JS, it will look it up in the cache, +/// which completely avoids the `O(n)` copy and encoding. This has a significant +/// speed boost (as high as 783%)! +/// +/// However, there is a small cost to this caching, so you shouldn't cache every +/// string. Only cache strings which have a high likelihood of being sent +/// to JS multiple times. +/// +/// Also, keep in mind that this function is a *performance hint*: it's not +/// *guaranteed* that the string will be cached, and the caching strategy +/// might change at any time, so don't rely upon it. +#[inline] +pub fn intern(s: &str) -> &str { + #[cfg(feature = "enable-interning")] + intern_str(s); + + s +} + + +/// Removes a Rust string from the intern cache. +/// +/// This does the opposite of the [`intern`](fn.intern.html) function. +/// +/// If the [`intern`](fn.intern.html) function is called again then it will re-intern the string. +#[allow(unused_variables)] +#[inline] +pub fn unintern(s: &str) { + #[cfg(feature = "enable-interning")] + unintern_str(s); +} diff --git a/vendor/wasm-bindgen/src/cache/mod.rs b/vendor/wasm-bindgen/src/cache/mod.rs new file mode 100644 index 000000000..96d1a4920 --- /dev/null +++ b/vendor/wasm-bindgen/src/cache/mod.rs @@ -0,0 +1 @@ +pub mod intern; diff --git a/vendor/wasm-bindgen/src/cast.rs b/vendor/wasm-bindgen/src/cast.rs new file mode 100644 index 000000000..6be56a2d7 --- /dev/null +++ b/vendor/wasm-bindgen/src/cast.rs @@ -0,0 +1,160 @@ +use crate::{describe::WasmDescribe, JsValue}; + +/// A trait for checked and unchecked casting between JS types. +/// +/// Specified [in an RFC][rfc] this trait is intended to provide support for +/// casting JS values between differnet types of one another. In JS there aren't +/// many static types but we've ascribed JS values with static types in Rust, +/// yet they often need to be switched to other types temporarily! This trait +/// provides both checked and unchecked casting into various kinds of values. +/// +/// This trait is automatically implemented for any type imported in a +/// `#[wasm_bindgen]` `extern` block. +/// +/// [rfc]: https://github.com/rustwasm/rfcs/blob/master/text/002-wasm-bindgen-inheritance-casting.md +pub trait JsCast +where + Self: AsRef + Into, +{ + /// Test whether this JS value has a type `T`. + /// + /// This method will dynamically check to see if this JS object can be + /// casted to the JS object of type `T`. Usually this uses the `instanceof` + /// operator. This also works with primitive types like + /// booleans/strings/numbers as well as cross-realm object like `Array` + /// which can originate from other iframes. + /// + /// In general this is intended to be a more robust version of + /// `is_instance_of`, but if you want strictly the `instanceof` operator + /// it's recommended to use that instead. + fn has_type(&self) -> bool + where + T: JsCast, + { + T::is_type_of(self.as_ref()) + } + + /// Performs a dynamic cast (checked at runtime) of this value into the + /// target type `T`. + /// + /// This method will return `Err(self)` if `self.has_type::()` + /// returns `false`, and otherwise it will return `Ok(T)` manufactured with + /// an unchecked cast (verified correct via the `has_type` operation). + fn dyn_into(self) -> Result + where + T: JsCast, + { + if self.has_type::() { + Ok(self.unchecked_into()) + } else { + Err(self) + } + } + + /// Performs a dynamic cast (checked at runtime) of this value into the + /// target type `T`. + /// + /// This method will return `None` if `self.has_type::()` + /// returns `false`, and otherwise it will return `Some(&T)` manufactured + /// with an unchecked cast (verified correct via the `has_type` operation). + fn dyn_ref(&self) -> Option<&T> + where + T: JsCast, + { + if self.has_type::() { + Some(self.unchecked_ref()) + } else { + None + } + } + + /// Performs a zero-cost unchecked cast into the specified type. + /// + /// This method will convert the `self` value to the type `T`, where both + /// `self` and `T` are simple wrappers around `JsValue`. This method **does + /// not check whether `self` is an instance of `T`**. If used incorrectly + /// then this method may cause runtime exceptions in both Rust and JS, this + /// should be used with caution. + fn unchecked_into(self) -> T + where + T: JsCast, + { + T::unchecked_from_js(self.into()) + } + + /// Performs a zero-cost unchecked cast into a reference to the specified + /// type. + /// + /// This method will convert the `self` value to the type `T`, where both + /// `self` and `T` are simple wrappers around `JsValue`. This method **does + /// not check whether `self` is an instance of `T`**. If used incorrectly + /// then this method may cause runtime exceptions in both Rust and JS, this + /// should be used with caution. + /// + /// This method, unlike `unchecked_into`, does not consume ownership of + /// `self` and instead works over a shared reference. + fn unchecked_ref(&self) -> &T + where + T: JsCast, + { + T::unchecked_from_js_ref(self.as_ref()) + } + + /// Test whether this JS value is an instance of the type `T`. + /// + /// This method performs a dynamic check (at runtime) using the JS + /// `instanceof` operator. This method returns `self instanceof T`. + /// + /// Note that `instanceof` does not always work with primitive values or + /// across different realms (e.g. iframes). If you're not sure whether you + /// specifically need only `instanceof` it's recommended to use `has_type` + /// instead. + fn is_instance_of(&self) -> bool + where + T: JsCast, + { + T::instanceof(self.as_ref()) + } + + /// Performs a dynamic `instanceof` check to see whether the `JsValue` + /// provided is an instance of this type. + /// + /// This is intended to be an internal implementation detail, you likely + /// won't need to call this. It's generally called through the + /// `is_instance_of` method instead. + fn instanceof(val: &JsValue) -> bool; + + /// Performs a dynamic check to see whether the `JsValue` provided + /// is a value of this type. + /// + /// Unlike `instanceof`, this can be specialised to use a custom check by + /// adding a `#[wasm_bindgen(is_type_of = callback)]` attribute to the + /// type import declaration. + /// + /// Other than that, this is intended to be an internal implementation + /// detail of `has_type` and you likely won't need to call this. + fn is_type_of(val: &JsValue) -> bool { + Self::instanceof(val) + } + + /// Performs a zero-cost unchecked conversion from a `JsValue` into an + /// instance of `Self` + /// + /// This is intended to be an internal implementation detail, you likely + /// won't need to call this. + fn unchecked_from_js(val: JsValue) -> Self; + + /// Performs a zero-cost unchecked conversion from a `&JsValue` into an + /// instance of `&Self`. + /// + /// Note the safety of this method, which basically means that `Self` must + /// be a newtype wrapper around `JsValue`. + /// + /// This is intended to be an internal implementation detail, you likely + /// won't need to call this. + fn unchecked_from_js_ref(val: &JsValue) -> &Self; +} + +/// Trait implemented for wrappers around `JsValue`s generated by `#[wasm_bindgen]`. +#[doc(hidden)] +pub trait JsObject: JsCast + WasmDescribe {} diff --git a/vendor/wasm-bindgen/src/closure.rs b/vendor/wasm-bindgen/src/closure.rs new file mode 100644 index 000000000..37cef06dc --- /dev/null +++ b/vendor/wasm-bindgen/src/closure.rs @@ -0,0 +1,885 @@ +//! Support for long-lived closures in `wasm-bindgen` +//! +//! This module defines the `Closure` type which is used to pass "owned +//! closures" from Rust to JS. Some more details can be found on the `Closure` +//! type itself. + +use std::fmt; +use std::mem::{self, ManuallyDrop}; +use std::prelude::v1::*; + +use crate::convert::*; +use crate::describe::*; +use crate::throw_str; +use crate::JsValue; +use crate::UnwrapThrowExt; + +/// A handle to both a closure in Rust as well as JS closure which will invoke +/// the Rust closure. +/// +/// A `Closure` is the primary way that a `'static` lifetime closure is +/// transferred from Rust to JS. `Closure` currently requires that the closures +/// it's created with have the `'static` lifetime in Rust for soundness reasons. +/// +/// This type is a "handle" in the sense that whenever it is dropped it will +/// invalidate the JS closure that it refers to. Any usage of the closure in JS +/// after the `Closure` has been dropped will raise an exception. It's then up +/// to you to arrange for `Closure` to be properly deallocate at an appropriate +/// location in your program. +/// +/// The type parameter on `Closure` is the type of closure that this represents. +/// Currently this can only be the `Fn` and `FnMut` traits with up to 7 +/// arguments (and an optional return value). +/// +/// # Examples +/// +/// Here are a number of examples of using `Closure`. +/// +/// ## Using the `setInterval` API +/// +/// Sample usage of `Closure` to invoke the `setInterval` API. +/// +/// ```rust,no_run +/// use wasm_bindgen::prelude::*; +/// +/// #[wasm_bindgen] +/// extern "C" { +/// fn setInterval(closure: &Closure, time: u32) -> i32; +/// fn clearInterval(id: i32); +/// +/// #[wasm_bindgen(js_namespace = console)] +/// fn log(s: &str); +/// } +/// +/// #[wasm_bindgen] +/// pub struct IntervalHandle { +/// interval_id: i32, +/// _closure: Closure, +/// } +/// +/// impl Drop for IntervalHandle { +/// fn drop(&mut self) { +/// clearInterval(self.interval_id); +/// } +/// } +/// +/// #[wasm_bindgen] +/// pub fn run() -> IntervalHandle { +/// // First up we use `Closure::new` to wrap up a Rust closure and create +/// // a JS closure. +/// let cb = Closure::new(|| { +/// log("interval elapsed!"); +/// }); +/// +/// // Next we pass this via reference to the `setInterval` function, and +/// // `setInterval` gets a handle to the corresponding JS closure. +/// let interval_id = setInterval(&cb, 1_000); +/// +/// // If we were to drop `cb` here it would cause an exception to be raised +/// // whenever the interval elapses. Instead we *return* our handle back to JS +/// // so JS can decide when to cancel the interval and deallocate the closure. +/// IntervalHandle { +/// interval_id, +/// _closure: cb, +/// } +/// } +/// ``` +/// +/// ## Casting a `Closure` to a `js_sys::Function` +/// +/// This is the same `setInterval` example as above, except it is using +/// `web_sys` (which uses `js_sys::Function` for callbacks) instead of manually +/// writing bindings to `setInterval` and other Web APIs. +/// +/// ```rust,ignore +/// use wasm_bindgen::JsCast; +/// +/// #[wasm_bindgen] +/// pub struct IntervalHandle { +/// interval_id: i32, +/// _closure: Closure, +/// } +/// +/// impl Drop for IntervalHandle { +/// fn drop(&mut self) { +/// let window = web_sys::window().unwrap(); +/// window.clear_interval_with_handle(self.interval_id); +/// } +/// } +/// +/// #[wasm_bindgen] +/// pub fn run() -> Result { +/// let cb = Closure::new(|| { +/// web_sys::console::log_1(&"interval elapsed!".into()); +/// }); +/// +/// let window = web_sys::window().unwrap(); +/// let interval_id = window.set_interval_with_callback_and_timeout_and_arguments_0( +/// // Note this method call, which uses `as_ref()` to get a `JsValue` +/// // from our `Closure` which is then converted to a `&Function` +/// // using the `JsCast::unchecked_ref` function. +/// cb.as_ref().unchecked_ref(), +/// 1_000, +/// )?; +/// +/// // Same as above. +/// Ok(IntervalHandle { +/// interval_id, +/// _closure: cb, +/// }) +/// } +/// ``` +/// +/// ## Using `FnOnce` and `Closure::once` with `requestAnimationFrame` +/// +/// Because `requestAnimationFrame` only calls its callback once, we can use +/// `FnOnce` and `Closure::once` with it. +/// +/// ```rust,no_run +/// use wasm_bindgen::prelude::*; +/// +/// #[wasm_bindgen] +/// extern "C" { +/// fn requestAnimationFrame(closure: &Closure) -> u32; +/// fn cancelAnimationFrame(id: u32); +/// +/// #[wasm_bindgen(js_namespace = console)] +/// fn log(s: &str); +/// } +/// +/// #[wasm_bindgen] +/// pub struct AnimationFrameHandle { +/// animation_id: u32, +/// _closure: Closure, +/// } +/// +/// impl Drop for AnimationFrameHandle { +/// fn drop(&mut self) { +/// cancelAnimationFrame(self.animation_id); +/// } +/// } +/// +/// // A type that will log a message when it is dropped. +/// struct LogOnDrop(&'static str); +/// impl Drop for LogOnDrop { +/// fn drop(&mut self) { +/// log(self.0); +/// } +/// } +/// +/// #[wasm_bindgen] +/// pub fn run() -> AnimationFrameHandle { +/// // We are using `Closure::once` which takes a `FnOnce`, so the function +/// // can drop and/or move things that it closes over. +/// let fired = LogOnDrop("animation frame fired or canceled"); +/// let cb = Closure::once(move || drop(fired)); +/// +/// // Schedule the animation frame! +/// let animation_id = requestAnimationFrame(&cb); +/// +/// // Again, return a handle to JS, so that the closure is not dropped +/// // immediately and JS can decide whether to cancel the animation frame. +/// AnimationFrameHandle { +/// animation_id, +/// _closure: cb, +/// } +/// } +/// ``` +/// +/// ## Converting `FnOnce`s directly into JavaScript Functions with `Closure::once_into_js` +/// +/// If we don't want to allow a `FnOnce` to be eagerly dropped (maybe because we +/// just want it to drop after it is called and don't care about cancellation) +/// then we can use the `Closure::once_into_js` function. +/// +/// This is the same `requestAnimationFrame` example as above, but without +/// supporting early cancellation. +/// +/// ``` +/// use wasm_bindgen::prelude::*; +/// +/// #[wasm_bindgen] +/// extern "C" { +/// // We modify the binding to take an untyped `JsValue` since that is what +/// // is returned by `Closure::once_into_js`. +/// // +/// // If we were using the `web_sys` binding for `requestAnimationFrame`, +/// // then the call sites would cast the `JsValue` into a `&js_sys::Function` +/// // using `f.unchecked_ref::()`. See the `web_sys` +/// // example above for details. +/// fn requestAnimationFrame(callback: JsValue); +/// +/// #[wasm_bindgen(js_namespace = console)] +/// fn log(s: &str); +/// } +/// +/// // A type that will log a message when it is dropped. +/// struct LogOnDrop(&'static str); +/// impl Drop for LogOnDrop { +/// fn drop(&mut self) { +/// log(self.0); +/// } +/// } +/// +/// #[wasm_bindgen] +/// pub fn run() { +/// // We are using `Closure::once_into_js` which takes a `FnOnce` and +/// // converts it into a JavaScript function, which is returned as a +/// // `JsValue`. +/// let fired = LogOnDrop("animation frame fired"); +/// let cb = Closure::once_into_js(move || drop(fired)); +/// +/// // Schedule the animation frame! +/// requestAnimationFrame(cb); +/// +/// // No need to worry about whether or not we drop a `Closure` +/// // here or return some sort of handle to JS! +/// } +/// ``` +pub struct Closure { + js: ManuallyDrop, + data: ManuallyDrop>, +} + +union FatPtr { + ptr: *mut T, + fields: (usize, usize), +} + +impl Closure +where + T: ?Sized + WasmClosure, +{ + /// Creates a new instance of `Closure` from the provided Rust function. + /// + /// Note that the closure provided here, `F`, has a few requirements + /// associated with it: + /// + /// * It must implement `Fn` or `FnMut` (for `FnOnce` functions see + /// `Closure::once` and `Closure::once_into_js`). + /// + /// * It must be `'static`, aka no stack references (use the `move` + /// keyword). + /// + /// * It can have at most 7 arguments. + /// + /// * Its arguments and return values are all types that can be shared with + /// JS (i.e. have `#[wasm_bindgen]` annotations or are simple numbers, + /// etc.) + pub fn new(t: F) -> Closure + where + F: IntoWasmClosure + 'static, + { + Closure::wrap(Box::new(t).unsize()) + } + + /// A more direct version of `Closure::new` which creates a `Closure` from + /// a `Box`/`Box`, which is how it's kept internally. + pub fn wrap(mut data: Box) -> Closure { + assert_eq!(mem::size_of::<*const T>(), mem::size_of::>()); + let (a, b) = unsafe { + FatPtr { + ptr: &mut *data as *mut T, + } + .fields + }; + + // Here we need to create a `JsValue` with the data and `T::invoke()` + // function pointer. To do that we... take a few unconventional turns. + // In essence what happens here is this: + // + // 1. First up, below we call a function, `breaks_if_inlined`. This + // function, as the name implies, does not work if it's inlined. + // More on that in a moment. + // 2. This function internally calls a special import recognized by the + // `wasm-bindgen` CLI tool, `__wbindgen_describe_closure`. This + // imported symbol is similar to `__wbindgen_describe` in that it's + // not intended to show up in the final binary but it's an + // intermediate state for a `wasm-bindgen` binary. + // 3. The `__wbindgen_describe_closure` import is namely passed a + // descriptor function, monomorphized for each invocation. + // + // Most of this doesn't actually make sense to happen at runtime! The + // real magic happens when `wasm-bindgen` comes along and updates our + // generated code. When `wasm-bindgen` runs it performs a few tasks: + // + // * First, it finds all functions that call + // `__wbindgen_describe_closure`. These are all `breaks_if_inlined` + // defined below as the symbol isn't called anywhere else. + // * Next, `wasm-bindgen` executes the `breaks_if_inlined` + // monomorphized functions, passing it dummy arguments. This will + // execute the function just enough to invoke the special import, + // namely telling us about the function pointer that is the describe + // shim. + // * This knowledge is then used to actually find the descriptor in the + // function table which is then executed to figure out the signature + // of the closure. + // * Finally, and probably most heinously, the call to + // `breaks_if_inlined` is rewritten to call an otherwise globally + // imported function. This globally imported function will generate + // the `JsValue` for this closure specialized for the signature in + // question. + // + // Later on `wasm-gc` will clean up all the dead code and ensure that + // we don't actually call `__wbindgen_describe_closure` at runtime. This + // means we will end up not actually calling `breaks_if_inlined` in the + // final binary, all calls to that function should be pruned. + // + // See crates/cli-support/src/js/closures.rs for a more information + // about what's going on here. + + extern "C" fn describe() { + inform(CLOSURE); + T::describe() + } + + #[inline(never)] + unsafe fn breaks_if_inlined(a: usize, b: usize) -> u32 { + super::__wbindgen_describe_closure(a as u32, b as u32, describe:: as u32) + } + + let idx = unsafe { breaks_if_inlined::(a, b) }; + + Closure { + js: ManuallyDrop::new(JsValue::_new(idx)), + data: ManuallyDrop::new(data), + } + } + + /// Release memory management of this closure from Rust to the JS GC. + /// + /// When a `Closure` is dropped it will release the Rust memory and + /// invalidate the associated JS closure, but this isn't always desired. + /// Some callbacks are alive for the entire duration of the program or for a + /// lifetime dynamically managed by the JS GC. This function can be used + /// to drop this `Closure` while keeping the associated JS function still + /// valid. + /// + /// By default this function will leak memory. This can be dangerous if this + /// function is called many times in an application because the memory leak + /// will overwhelm the page quickly and crash the wasm. + /// + /// If the browser, however, supports weak references, then this function + /// will not leak memory. Instead the Rust memory will be reclaimed when the + /// JS closure is GC'd. Weak references are not enabled by default since + /// they're still a proposal for the JS standard. They can be enabled with + /// `WASM_BINDGEN_WEAKREF=1` when running `wasm-bindgen`, however. + pub fn into_js_value(self) -> JsValue { + let idx = self.js.idx; + mem::forget(self); + JsValue::_new(idx) + } + + /// Same as `into_js_value`, but doesn't return a value. + pub fn forget(self) { + drop(self.into_js_value()); + } +} + +// NB: we use a specific `T` for this `Closure` impl block to avoid every +// call site having to provide an explicit, turbo-fished type like +// `Closure::::once(...)`. +impl Closure { + /// Create a `Closure` from a function that can only be called once. + /// + /// Since we have no way of enforcing that JS cannot attempt to call this + /// `FnOne(A...) -> R` more than once, this produces a `Closure R>` that will dynamically throw a JavaScript error if called more + /// than once. + /// + /// # Example + /// + /// ```rust,no_run + /// use wasm_bindgen::prelude::*; + /// + /// // Create an non-`Copy`, owned `String`. + /// let mut s = String::from("Hello"); + /// + /// // Close over `s`. Since `f` returns `s`, it is `FnOnce` and can only be + /// // called once. If it was called a second time, it wouldn't have any `s` + /// // to work with anymore! + /// let f = move || { + /// s += ", World!"; + /// s + /// }; + /// + /// // Create a `Closure` from `f`. Note that the `Closure`'s type parameter + /// // is `FnMut`, even though `f` is `FnOnce`. + /// let closure: Closure String> = Closure::once(f); + /// ``` + pub fn once(fn_once: F) -> Closure + where + F: 'static + WasmClosureFnOnce, + { + Closure::wrap(fn_once.into_fn_mut()) + } + + /// Convert a `FnOnce(A...) -> R` into a JavaScript `Function` object. + /// + /// If the JavaScript function is invoked more than once, it will throw an + /// exception. + /// + /// Unlike `Closure::once`, this does *not* return a `Closure` that can be + /// dropped before the function is invoked to deallocate the closure. The + /// only way the `FnOnce` is deallocated is by calling the JavaScript + /// function. If the JavaScript function is never called then the `FnOnce` + /// and everything it closes over will leak. + /// + /// ```rust,ignore + /// use wasm_bindgen::{prelude::*, JsCast}; + /// + /// let f = Closure::once_into_js(move || { + /// // ... + /// }); + /// + /// assert!(f.is_instance_of::()); + /// ``` + pub fn once_into_js(fn_once: F) -> JsValue + where + F: 'static + WasmClosureFnOnce, + { + fn_once.into_js_function() + } +} + +/// A trait for converting an `FnOnce(A...) -> R` into a `FnMut(A...) -> R` that +/// will throw if ever called more than once. +#[doc(hidden)] +pub trait WasmClosureFnOnce: 'static { + type FnMut: ?Sized + 'static + WasmClosure; + + fn into_fn_mut(self) -> Box; + + fn into_js_function(self) -> JsValue; +} + +impl AsRef for Closure { + fn as_ref(&self) -> &JsValue { + &self.js + } +} + +impl WasmDescribe for Closure +where + T: WasmClosure + ?Sized, +{ + fn describe() { + inform(EXTERNREF); + } +} + +// `Closure` can only be passed by reference to imports. +impl<'a, T> IntoWasmAbi for &'a Closure +where + T: WasmClosure + ?Sized, +{ + type Abi = u32; + + fn into_abi(self) -> u32 { + (&*self.js).into_abi() + } +} + +impl<'a, T> OptionIntoWasmAbi for &'a Closure +where + T: WasmClosure + ?Sized, +{ + fn none() -> Self::Abi { + 0 + } +} + +fn _check() { + fn _assert() {} + _assert::<&Closure>(); + _assert::<&Closure>(); + _assert::<&Closure String>>(); + _assert::<&Closure>(); + _assert::<&Closure>(); + _assert::<&Closure String>>(); +} + +impl fmt::Debug for Closure +where + T: ?Sized, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Closure {{ ... }}") + } +} + +impl Drop for Closure +where + T: ?Sized, +{ + fn drop(&mut self) { + unsafe { + // this will implicitly drop our strong reference in addition to + // invalidating all future invocations of the closure + if super::__wbindgen_cb_drop(self.js.idx) != 0 { + ManuallyDrop::drop(&mut self.data); + } + } + } +} + +/// An internal trait for the `Closure` type. +/// +/// This trait is not stable and it's not recommended to use this in bounds or +/// implement yourself. +#[doc(hidden)] +pub unsafe trait WasmClosure { + fn describe(); +} + +/// An internal trait for the `Closure` type. +/// +/// This trait is not stable and it's not recommended to use this in bounds or +/// implement yourself. +#[doc(hidden)] +pub trait IntoWasmClosure { + fn unsize(self: Box) -> Box; +} + +// The memory safety here in these implementations below is a bit tricky. We +// want to be able to drop the `Closure` object from within the invocation of a +// `Closure` for cases like promises. That means that while it's running we +// might drop the `Closure`, but that shouldn't invalidate the environment yet. +// +// Instead what we do is to wrap closures in `Rc` variables. The main `Closure` +// has a strong reference count which keeps the trait object alive. Each +// invocation of a closure then *also* clones this and gets a new reference +// count. When the closure returns it will release the reference count. +// +// This means that if the main `Closure` is dropped while it's being invoked +// then destruction is deferred until execution returns. Otherwise it'll +// deallocate data immediately. + +macro_rules! doit { + ($( + ($($var:ident)*) + )*) => ($( + unsafe impl<$($var,)* R> WasmClosure for dyn Fn($($var),*) -> R + 'static + where $($var: FromWasmAbi + 'static,)* + R: ReturnWasmAbi + 'static, + { + fn describe() { + #[allow(non_snake_case)] + unsafe extern "C" fn invoke<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + $($var: <$var as FromWasmAbi>::Abi),* + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Make sure all stack variables are converted before we + // convert `ret` as it may throw (for `Result`, for + // example) + let ret = { + let f: *const dyn Fn($($var),*) -> R = + FatPtr { fields: (a, b) }.ptr; + $( + let $var = <$var as FromWasmAbi>::from_abi($var); + )* + (*f)($($var),*) + }; + ret.return_abi() + } + + inform(invoke::<$($var,)* R> as u32); + + unsafe extern fn destroy<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + ) { + // This can be called by the JS glue in erroneous situations + // such as when the closure has already been destroyed. If + // that's the case let's not make things worse by + // segfaulting and/or asserting, so just ignore null + // pointers. + if a == 0 { + return; + } + drop(Box::from_raw(FatPtr:: R> { + fields: (a, b) + }.ptr)); + } + inform(destroy::<$($var,)* R> as u32); + + <&Self>::describe(); + } + } + + unsafe impl<$($var,)* R> WasmClosure for dyn FnMut($($var),*) -> R + 'static + where $($var: FromWasmAbi + 'static,)* + R: ReturnWasmAbi + 'static, + { + fn describe() { + #[allow(non_snake_case)] + unsafe extern "C" fn invoke<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + $($var: <$var as FromWasmAbi>::Abi),* + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Make sure all stack variables are converted before we + // convert `ret` as it may throw (for `Result`, for + // example) + let ret = { + let f: *const dyn FnMut($($var),*) -> R = + FatPtr { fields: (a, b) }.ptr; + let f = f as *mut dyn FnMut($($var),*) -> R; + $( + let $var = <$var as FromWasmAbi>::from_abi($var); + )* + (*f)($($var),*) + }; + ret.return_abi() + } + + inform(invoke::<$($var,)* R> as u32); + + unsafe extern fn destroy<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + ) { + // See `Fn()` above for why we simply return + if a == 0 { + return; + } + drop(Box::from_raw(FatPtr:: R> { + fields: (a, b) + }.ptr)); + } + inform(destroy::<$($var,)* R> as u32); + + <&mut Self>::describe(); + } + } + + #[allow(non_snake_case, unused_parens)] + impl WasmClosureFnOnce<($($var),*), R> for T + where T: 'static + FnOnce($($var),*) -> R, + $($var: FromWasmAbi + 'static,)* + R: ReturnWasmAbi + 'static + { + type FnMut = dyn FnMut($($var),*) -> R; + + fn into_fn_mut(self) -> Box { + let mut me = Some(self); + Box::new(move |$($var),*| { + let me = me.take().expect_throw("FnOnce called more than once"); + me($($var),*) + }) + } + + fn into_js_function(self) -> JsValue { + use std::rc::Rc; + use crate::__rt::WasmRefCell; + + let mut me = Some(self); + + let rc1 = Rc::new(WasmRefCell::new(None)); + let rc2 = rc1.clone(); + + let closure = Closure::wrap(Box::new(move |$($var),*| { + // Invoke ourself and get the result. + let me = me.take().expect_throw("FnOnce called more than once"); + let result = me($($var),*); + + // And then drop the `Rc` holding this function's `Closure` + // alive. + debug_assert_eq!(Rc::strong_count(&rc2), 1); + let option_closure = rc2.borrow_mut().take(); + debug_assert!(option_closure.is_some()); + drop(option_closure); + + result + }) as Box R>); + + let js_val = closure.as_ref().clone(); + + *rc1.borrow_mut() = Some(closure); + debug_assert_eq!(Rc::strong_count(&rc1), 2); + drop(rc1); + + js_val + } + } + + impl IntoWasmClosure R> for T + where T: 'static + FnMut($($var),*) -> R, + $($var: FromWasmAbi + 'static,)* + R: ReturnWasmAbi + 'static, + { + fn unsize(self: Box) -> Box R> { self } + } + + impl IntoWasmClosure R> for T + where T: 'static + Fn($($var),*) -> R, + $($var: FromWasmAbi + 'static,)* + R: ReturnWasmAbi + 'static, + { + fn unsize(self: Box) -> Box R> { self } + } + )*) +} + +doit! { + () + (A) + (A B) + (A B C) + (A B C D) + (A B C D E) + (A B C D E F) + (A B C D E F G) + (A B C D E F G H) +} + +// Copy the above impls down here for where there's only one argument and it's a +// reference. We could add more impls for more kinds of references, but it +// becomes a combinatorial explosion quickly. Let's see how far we can get with +// just this one! Maybe someone else can figure out voodoo so we don't have to +// duplicate. + +unsafe impl WasmClosure for dyn Fn(&A) -> R +where + A: RefFromWasmAbi, + R: ReturnWasmAbi + 'static, +{ + fn describe() { + #[allow(non_snake_case)] + unsafe extern "C" fn invoke( + a: usize, + b: usize, + arg: ::Abi, + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Make sure all stack variables are converted before we + // convert `ret` as it may throw (for `Result`, for + // example) + let ret = { + let f: *const dyn Fn(&A) -> R = FatPtr { fields: (a, b) }.ptr; + let arg = ::ref_from_abi(arg); + (*f)(&*arg) + }; + ret.return_abi() + } + + inform(invoke:: as u32); + + unsafe extern "C" fn destroy(a: usize, b: usize) { + // See `Fn()` above for why we simply return + if a == 0 { + return; + } + drop(Box::from_raw( + FatPtr:: R> { fields: (a, b) }.ptr, + )); + } + inform(destroy:: as u32); + + <&Self>::describe(); + } +} + +unsafe impl WasmClosure for dyn FnMut(&A) -> R +where + A: RefFromWasmAbi, + R: ReturnWasmAbi + 'static, +{ + fn describe() { + #[allow(non_snake_case)] + unsafe extern "C" fn invoke( + a: usize, + b: usize, + arg: ::Abi, + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Make sure all stack variables are converted before we + // convert `ret` as it may throw (for `Result`, for + // example) + let ret = { + let f: *const dyn FnMut(&A) -> R = FatPtr { fields: (a, b) }.ptr; + let f = f as *mut dyn FnMut(&A) -> R; + let arg = ::ref_from_abi(arg); + (*f)(&*arg) + }; + ret.return_abi() + } + + inform(invoke:: as u32); + + unsafe extern "C" fn destroy(a: usize, b: usize) { + // See `Fn()` above for why we simply return + if a == 0 { + return; + } + drop(Box::from_raw( + FatPtr:: R> { fields: (a, b) }.ptr, + )); + } + inform(destroy:: as u32); + + <&mut Self>::describe(); + } +} + +#[allow(non_snake_case)] +impl WasmClosureFnOnce<(&A,), R> for T +where + T: 'static + FnOnce(&A) -> R, + A: RefFromWasmAbi + 'static, + R: ReturnWasmAbi + 'static, +{ + type FnMut = dyn FnMut(&A) -> R; + + fn into_fn_mut(self) -> Box { + let mut me = Some(self); + Box::new(move |arg| { + let me = me.take().expect_throw("FnOnce called more than once"); + me(arg) + }) + } + + fn into_js_function(self) -> JsValue { + use crate::__rt::WasmRefCell; + use std::rc::Rc; + + let mut me = Some(self); + + let rc1 = Rc::new(WasmRefCell::new(None)); + let rc2 = rc1.clone(); + + let closure = Closure::wrap(Box::new(move |arg: &A| { + // Invoke ourself and get the result. + let me = me.take().expect_throw("FnOnce called more than once"); + let result = me(arg); + + // And then drop the `Rc` holding this function's `Closure` + // alive. + debug_assert_eq!(Rc::strong_count(&rc2), 1); + let option_closure = rc2.borrow_mut().take(); + debug_assert!(option_closure.is_some()); + drop(option_closure); + + result + }) as Box R>); + + let js_val = closure.as_ref().clone(); + + *rc1.borrow_mut() = Some(closure); + debug_assert_eq!(Rc::strong_count(&rc1), 2); + drop(rc1); + + js_val + } +} diff --git a/vendor/wasm-bindgen/src/convert/closures.rs b/vendor/wasm-bindgen/src/convert/closures.rs new file mode 100644 index 000000000..97755b8ee --- /dev/null +++ b/vendor/wasm-bindgen/src/convert/closures.rs @@ -0,0 +1,225 @@ +use core::mem; + +use crate::convert::slices::WasmSlice; +use crate::convert::RefFromWasmAbi; +use crate::convert::{FromWasmAbi, IntoWasmAbi, ReturnWasmAbi}; +use crate::describe::{inform, WasmDescribe, FUNCTION}; +use crate::throw_str; + +macro_rules! stack_closures { + ($( ($cnt:tt $invoke:ident $invoke_mut:ident $($var:ident)*) )*) => ($( + impl<'a, 'b, $($var,)* R> IntoWasmAbi for &'a (dyn Fn($($var),*) -> R + 'b) + where $($var: FromWasmAbi,)* + R: ReturnWasmAbi + { + type Abi = WasmSlice; + + fn into_abi(self) -> WasmSlice { + unsafe { + let (a, b): (usize, usize) = mem::transmute(self); + WasmSlice { ptr: a as u32, len: b as u32 } + } + } + } + + #[allow(non_snake_case)] + unsafe extern "C" fn $invoke<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + $($var: <$var as FromWasmAbi>::Abi),* + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Scope all local variables before we call `return_abi` to + // ensure they're all destroyed as `return_abi` may throw + let ret = { + let f: &dyn Fn($($var),*) -> R = mem::transmute((a, b)); + $( + let $var = <$var as FromWasmAbi>::from_abi($var); + )* + f($($var),*) + }; + ret.return_abi() + } + + impl<'a, $($var,)* R> WasmDescribe for dyn Fn($($var),*) -> R + 'a + where $($var: FromWasmAbi,)* + R: ReturnWasmAbi + { + fn describe() { + inform(FUNCTION); + inform($invoke::<$($var,)* R> as u32); + inform($cnt); + $(<$var as WasmDescribe>::describe();)* + ::describe(); + ::describe(); + } + } + + impl<'a, 'b, $($var,)* R> IntoWasmAbi for &'a mut (dyn FnMut($($var),*) -> R + 'b) + where $($var: FromWasmAbi,)* + R: ReturnWasmAbi + { + type Abi = WasmSlice; + + fn into_abi(self) -> WasmSlice { + unsafe { + let (a, b): (usize, usize) = mem::transmute(self); + WasmSlice { ptr: a as u32, len: b as u32 } + } + } + } + + #[allow(non_snake_case)] + unsafe extern "C" fn $invoke_mut<$($var: FromWasmAbi,)* R: ReturnWasmAbi>( + a: usize, + b: usize, + $($var: <$var as FromWasmAbi>::Abi),* + ) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Scope all local variables before we call `return_abi` to + // ensure they're all destroyed as `return_abi` may throw + let ret = { + let f: &mut dyn FnMut($($var),*) -> R = mem::transmute((a, b)); + $( + let $var = <$var as FromWasmAbi>::from_abi($var); + )* + f($($var),*) + }; + ret.return_abi() + } + + impl<'a, $($var,)* R> WasmDescribe for dyn FnMut($($var),*) -> R + 'a + where $($var: FromWasmAbi,)* + R: ReturnWasmAbi + { + fn describe() { + inform(FUNCTION); + inform($invoke_mut::<$($var,)* R> as u32); + inform($cnt); + $(<$var as WasmDescribe>::describe();)* + ::describe(); + ::describe(); + } + } + )*) +} + +stack_closures! { + (0 invoke0 invoke0_mut) + (1 invoke1 invoke1_mut A) + (2 invoke2 invoke2_mut A B) + (3 invoke3 invoke3_mut A B C) + (4 invoke4 invoke4_mut A B C D) + (5 invoke5 invoke5_mut A B C D E) + (6 invoke6 invoke6_mut A B C D E F) + (7 invoke7 invoke7_mut A B C D E F G) + (8 invoke8 invoke8_mut A B C D E F G H) +} + +impl<'a, 'b, A, R> IntoWasmAbi for &'a (dyn Fn(&A) -> R + 'b) +where + A: RefFromWasmAbi, + R: ReturnWasmAbi, +{ + type Abi = WasmSlice; + + fn into_abi(self) -> WasmSlice { + unsafe { + let (a, b): (usize, usize) = mem::transmute(self); + WasmSlice { + ptr: a as u32, + len: b as u32, + } + } + } +} + +#[allow(non_snake_case)] +unsafe extern "C" fn invoke1_ref( + a: usize, + b: usize, + arg: ::Abi, +) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Scope all local variables before we call `return_abi` to + // ensure they're all destroyed as `return_abi` may throw + let ret = { + let f: &dyn Fn(&A) -> R = mem::transmute((a, b)); + let arg = ::ref_from_abi(arg); + f(&*arg) + }; + ret.return_abi() +} + +impl<'a, A, R> WasmDescribe for dyn Fn(&A) -> R + 'a +where + A: RefFromWasmAbi, + R: ReturnWasmAbi, +{ + fn describe() { + inform(FUNCTION); + inform(invoke1_ref:: as u32); + inform(1); + <&A as WasmDescribe>::describe(); + ::describe(); + ::describe(); + } +} + +impl<'a, 'b, A, R> IntoWasmAbi for &'a mut (dyn FnMut(&A) -> R + 'b) +where + A: RefFromWasmAbi, + R: ReturnWasmAbi, +{ + type Abi = WasmSlice; + + fn into_abi(self) -> WasmSlice { + unsafe { + let (a, b): (usize, usize) = mem::transmute(self); + WasmSlice { + ptr: a as u32, + len: b as u32, + } + } + } +} + +#[allow(non_snake_case)] +unsafe extern "C" fn invoke1_mut_ref( + a: usize, + b: usize, + arg: ::Abi, +) -> ::Abi { + if a == 0 { + throw_str("closure invoked recursively or destroyed already"); + } + // Scope all local variables before we call `return_abi` to + // ensure they're all destroyed as `return_abi` may throw + let ret = { + let f: &mut dyn FnMut(&A) -> R = mem::transmute((a, b)); + let arg = ::ref_from_abi(arg); + f(&*arg) + }; + ret.return_abi() +} + +impl<'a, A, R> WasmDescribe for dyn FnMut(&A) -> R + 'a +where + A: RefFromWasmAbi, + R: ReturnWasmAbi, +{ + fn describe() { + inform(FUNCTION); + inform(invoke1_mut_ref:: as u32); + inform(1); + <&A as WasmDescribe>::describe(); + ::describe(); + ::describe(); + } +} diff --git a/vendor/wasm-bindgen/src/convert/impls.rs b/vendor/wasm-bindgen/src/convert/impls.rs new file mode 100644 index 000000000..79ccd67af --- /dev/null +++ b/vendor/wasm-bindgen/src/convert/impls.rs @@ -0,0 +1,378 @@ +use core::char; +use core::mem::{self, ManuallyDrop}; + +use crate::convert::traits::WasmAbi; +use crate::convert::{FromWasmAbi, IntoWasmAbi, RefFromWasmAbi}; +use crate::convert::{OptionFromWasmAbi, OptionIntoWasmAbi, ReturnWasmAbi}; +use crate::{Clamped, JsError, JsValue}; + +unsafe impl WasmAbi for () {} + +#[repr(C, u32)] +pub enum WasmOption { + None, + Some(T), +} + +unsafe impl WasmAbi for WasmOption {} + +impl WasmOption { + pub fn from_option>(option: Option) -> Self { + match option { + Some(v) => WasmOption::Some(v.into_abi()), + None => WasmOption::None, + } + } + + pub unsafe fn into_option>(v: Self) -> Option { + match v { + WasmOption::Some(v) => Some(T::from_abi(v)), + WasmOption::None => None, + } + } +} + +macro_rules! type_wasm_native { + ($($t:tt as $c:tt)*) => ($( + impl IntoWasmAbi for $t { + type Abi = $c; + + #[inline] + fn into_abi(self) -> $c { self as $c } + } + + impl FromWasmAbi for $t { + type Abi = $c; + + #[inline] + unsafe fn from_abi(js: $c) -> Self { js as $t } + } + + impl IntoWasmAbi for Option<$t> { + type Abi = WasmOption<$c>; + + #[inline] + fn into_abi(self) -> Self::Abi { + WasmOption::from_option(self.map(|v| v as $c)) + } + } + + impl FromWasmAbi for Option<$t> { + type Abi = WasmOption<$c>; + + #[inline] + unsafe fn from_abi(js: Self::Abi) -> Self { + WasmOption::into_option(js).map(|v: $c| v as $t) + } + } + )*) +} + +type_wasm_native!( + i32 as i32 + isize as i32 + u32 as u32 + usize as u32 + i64 as i64 + u64 as u64 + f32 as f32 + f64 as f64 +); + +macro_rules! type_abi_as_u32 { + ($($t:tt)*) => ($( + impl IntoWasmAbi for $t { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { self as u32 } + } + + impl FromWasmAbi for $t { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> Self { js as $t } + } + + impl OptionIntoWasmAbi for $t { + #[inline] + fn none() -> u32 { 0x00FF_FFFFu32 } + } + + impl OptionFromWasmAbi for $t { + #[inline] + fn is_none(js: &u32) -> bool { *js == 0x00FF_FFFFu32 } + } + )*) +} + +type_abi_as_u32!(i8 u8 i16 u16); + +impl IntoWasmAbi for bool { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + self as u32 + } +} + +impl FromWasmAbi for bool { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> bool { + js != 0 + } +} + +impl OptionIntoWasmAbi for bool { + #[inline] + fn none() -> u32 { + 0x00FF_FFFFu32 + } +} + +impl OptionFromWasmAbi for bool { + #[inline] + fn is_none(js: &u32) -> bool { + *js == 0x00FF_FFFFu32 + } +} + +impl IntoWasmAbi for char { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + self as u32 + } +} + +impl FromWasmAbi for char { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> char { + char::from_u32_unchecked(js) + } +} + +impl OptionIntoWasmAbi for char { + #[inline] + fn none() -> u32 { + 0x00FF_FFFFu32 + } +} + +impl OptionFromWasmAbi for char { + #[inline] + fn is_none(js: &u32) -> bool { + *js == 0x00FF_FFFFu32 + } +} + +impl IntoWasmAbi for *const T { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + self as u32 + } +} + +impl FromWasmAbi for *const T { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> *const T { + js as *const T + } +} + +impl IntoWasmAbi for *mut T { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + self as u32 + } +} + +impl FromWasmAbi for *mut T { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> *mut T { + js as *mut T + } +} + +impl IntoWasmAbi for JsValue { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + let ret = self.idx; + mem::forget(self); + ret + } +} + +impl FromWasmAbi for JsValue { + type Abi = u32; + + #[inline] + unsafe fn from_abi(js: u32) -> JsValue { + JsValue::_new(js) + } +} + +impl<'a> IntoWasmAbi for &'a JsValue { + type Abi = u32; + + #[inline] + fn into_abi(self) -> u32 { + self.idx + } +} + +impl RefFromWasmAbi for JsValue { + type Abi = u32; + type Anchor = ManuallyDrop; + + #[inline] + unsafe fn ref_from_abi(js: u32) -> Self::Anchor { + ManuallyDrop::new(JsValue::_new(js)) + } +} + +impl IntoWasmAbi for Option { + type Abi = T::Abi; + + #[inline] + fn into_abi(self) -> T::Abi { + match self { + None => T::none(), + Some(me) => me.into_abi(), + } + } +} + +impl FromWasmAbi for Option { + type Abi = T::Abi; + + #[inline] + unsafe fn from_abi(js: T::Abi) -> Self { + if T::is_none(&js) { + None + } else { + Some(T::from_abi(js)) + } + } +} + +impl IntoWasmAbi for Clamped { + type Abi = T::Abi; + + #[inline] + fn into_abi(self) -> Self::Abi { + self.0.into_abi() + } +} + +impl FromWasmAbi for Clamped { + type Abi = T::Abi; + + #[inline] + unsafe fn from_abi(js: T::Abi) -> Self { + Clamped(T::from_abi(js)) + } +} + +impl IntoWasmAbi for () { + type Abi = (); + + #[inline] + fn into_abi(self) { + self + } +} + +/// This is an encoding of a Result. It can only store things that can be decoded by the JS +/// bindings. +/// +/// At the moment, we do not write the exact struct packing layout of everything into the +/// glue/descriptions of datatypes, so T cannot be arbitrary. The current requirements of the +/// struct unpacker (StructUnpacker), which apply to ResultAbi as a whole, are as follows: +/// +/// - repr(C), of course +/// - u32/i32/f32/f64 fields at the "leaf fields" of the "field tree" +/// - layout equivalent to a completely flattened repr(C) struct, constructed by an in order +/// traversal of all the leaf fields in it. +/// +/// This means that you can't embed struct A(u32, f64) as struct B(u32, A); because the "completely +/// flattened" struct AB(u32, u32, f64) would miss the 4 byte padding that is actually present +/// within B and then as a consequence also miss the 4 byte padding within A that repr(C) inserts. +/// +/// The enemy is padding. Padding is only required when there is an `f64` field. So the enemy is +/// `f64` after anything else, particularly anything arbitrary. There is no smaller sized type, so +/// we don't need to worry about 1-byte integers, etc. It's best, therefore, to place your f64s +/// first in your structs, that's why we have `abi` first, although here it doesn't matter as the +/// other two fields total 8 bytes anyway. +/// +#[repr(C)] +pub struct ResultAbi { + /// This field is the same size/align as `T`. + abi: ResultAbiUnion, + /// Order of args here is such that we can pop() the possible error first, deal with it and + /// move on. Later fields are popped off the stack first. + err: u32, + is_err: u32, +} + +#[repr(C)] +pub union ResultAbiUnion { + // ManuallyDrop is #[repr(transparent)] + ok: std::mem::ManuallyDrop, + err: (), +} + +unsafe impl WasmAbi for ResultAbi {} +unsafe impl WasmAbi for ResultAbiUnion {} + +impl> ReturnWasmAbi for Result { + type Abi = ResultAbi; + #[inline] + fn return_abi(self) -> Self::Abi { + match self { + Ok(v) => { + let abi = ResultAbiUnion { + ok: std::mem::ManuallyDrop::new(v.into_abi()), + }; + ResultAbi { + abi, + is_err: 0, + err: 0, + } + } + Err(e) => { + let jsval = e.into(); + ResultAbi { + abi: ResultAbiUnion { err: () }, + is_err: 1, + err: jsval.into_abi(), + } + } + } + } +} + +impl IntoWasmAbi for JsError { + type Abi = ::Abi; + + fn into_abi(self) -> Self::Abi { + self.value.into_abi() + } +} diff --git a/vendor/wasm-bindgen/src/convert/mod.rs b/vendor/wasm-bindgen/src/convert/mod.rs new file mode 100644 index 000000000..ce2c0b2c8 --- /dev/null +++ b/vendor/wasm-bindgen/src/convert/mod.rs @@ -0,0 +1,11 @@ +//! This is mostly an internal module, no stability guarantees are provided. Use +//! at your own risk. + +mod closures; +mod impls; +mod slices; +mod traits; + +pub use self::impls::*; +pub use self::slices::WasmSlice; +pub use self::traits::*; diff --git a/vendor/wasm-bindgen/src/convert/slices.rs b/vendor/wasm-bindgen/src/convert/slices.rs new file mode 100644 index 000000000..9d0970f4e --- /dev/null +++ b/vendor/wasm-bindgen/src/convert/slices.rs @@ -0,0 +1,311 @@ +#[cfg(feature = "std")] +use std::prelude::v1::*; + +use core::slice; +use core::str; + +use crate::cast::JsObject; +use crate::convert::OptionIntoWasmAbi; +use crate::convert::{FromWasmAbi, IntoWasmAbi, RefFromWasmAbi, RefMutFromWasmAbi, WasmAbi}; +use cfg_if::cfg_if; + +if_std! { + use core::mem; + use crate::convert::OptionFromWasmAbi; +} + +#[repr(C)] +pub struct WasmSlice { + pub ptr: u32, + pub len: u32, +} + +unsafe impl WasmAbi for WasmSlice {} + +#[inline] +fn null_slice() -> WasmSlice { + WasmSlice { ptr: 0, len: 0 } +} + +macro_rules! vectors { + ($($t:ident)*) => ($( + if_std! { + impl IntoWasmAbi for Box<[$t]> { + type Abi = WasmSlice; + + #[inline] + fn into_abi(self) -> WasmSlice { + let ptr = self.as_ptr(); + let len = self.len(); + mem::forget(self); + WasmSlice { + ptr: ptr.into_abi(), + len: len as u32, + } + } + } + + impl OptionIntoWasmAbi for Box<[$t]> { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl FromWasmAbi for Box<[$t]> { + type Abi = WasmSlice; + + #[inline] + unsafe fn from_abi(js: WasmSlice) -> Self { + let ptr = <*mut $t>::from_abi(js.ptr); + let len = js.len as usize; + Vec::from_raw_parts(ptr, len, len).into_boxed_slice() + } + } + + impl OptionFromWasmAbi for Box<[$t]> { + #[inline] + fn is_none(slice: &WasmSlice) -> bool { slice.ptr == 0 } + } + } + + impl<'a> IntoWasmAbi for &'a [$t] { + type Abi = WasmSlice; + + #[inline] + fn into_abi(self) -> WasmSlice { + WasmSlice { + ptr: self.as_ptr().into_abi(), + len: self.len() as u32, + } + } + } + + impl<'a> OptionIntoWasmAbi for &'a [$t] { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl<'a> IntoWasmAbi for &'a mut [$t] { + type Abi = WasmSlice; + + #[inline] + fn into_abi(self) -> WasmSlice { + (&*self).into_abi() + } + } + + impl<'a> OptionIntoWasmAbi for &'a mut [$t] { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl RefFromWasmAbi for [$t] { + type Abi = WasmSlice; + type Anchor = Box<[$t]>; + + #[inline] + unsafe fn ref_from_abi(js: WasmSlice) -> Box<[$t]> { + >::from_abi(js) + } + } + + impl RefMutFromWasmAbi for [$t] { + type Abi = WasmSlice; + type Anchor = &'static mut [$t]; + + #[inline] + unsafe fn ref_mut_from_abi(js: WasmSlice) + -> &'static mut [$t] + { + slice::from_raw_parts_mut( + <*mut $t>::from_abi(js.ptr), + js.len as usize, + ) + } + } + )*) +} + +vectors! { + u8 i8 u16 i16 u32 i32 u64 i64 usize isize f32 f64 +} + +cfg_if! { + if #[cfg(feature = "enable-interning")] { + #[inline] + fn unsafe_get_cached_str(x: &str) -> Option { + // This uses 0 for the ptr as an indication that it is a JsValue and not a str. + crate::cache::intern::unsafe_get_str(x).map(|x| WasmSlice { ptr: 0, len: x }) + } + + } else { + #[inline] + fn unsafe_get_cached_str(_x: &str) -> Option { + None + } + } +} + +if_std! { + impl IntoWasmAbi for Vec where Box<[T]>: IntoWasmAbi { + type Abi = as IntoWasmAbi>::Abi; + + #[inline] + fn into_abi(self) -> Self::Abi { + self.into_boxed_slice().into_abi() + } + } + + impl OptionIntoWasmAbi for Vec where Box<[T]>: IntoWasmAbi { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl FromWasmAbi for Vec where Box<[T]>: FromWasmAbi { + type Abi = as FromWasmAbi>::Abi; + + #[inline] + unsafe fn from_abi(js: Self::Abi) -> Self { + >::from_abi(js).into() + } + } + + impl OptionFromWasmAbi for Vec where Box<[T]>: FromWasmAbi { + #[inline] + fn is_none(abi: &WasmSlice) -> bool { abi.ptr == 0 } + } + + impl IntoWasmAbi for String { + type Abi = as IntoWasmAbi>::Abi; + + #[inline] + fn into_abi(self) -> Self::Abi { + // This is safe because the JsValue is immediately looked up in the heap and + // then returned, so use-after-free cannot occur. + unsafe_get_cached_str(&self).unwrap_or_else(|| self.into_bytes().into_abi()) + } + } + + impl OptionIntoWasmAbi for String { + #[inline] + fn none() -> Self::Abi { null_slice() } + } + + impl FromWasmAbi for String { + type Abi = as FromWasmAbi>::Abi; + + #[inline] + unsafe fn from_abi(js: Self::Abi) -> Self { + String::from_utf8_unchecked(>::from_abi(js)) + } + } + + impl OptionFromWasmAbi for String { + #[inline] + fn is_none(slice: &WasmSlice) -> bool { slice.ptr == 0 } + } +} + +impl<'a> IntoWasmAbi for &'a str { + type Abi = <&'a [u8] as IntoWasmAbi>::Abi; + + #[inline] + fn into_abi(self) -> Self::Abi { + // This is safe because the JsValue is immediately looked up in the heap and + // then returned, so use-after-free cannot occur. + unsafe_get_cached_str(self).unwrap_or_else(|| self.as_bytes().into_abi()) + } +} + +impl<'a> OptionIntoWasmAbi for &'a str { + #[inline] + fn none() -> Self::Abi { + null_slice() + } +} + +impl RefFromWasmAbi for str { + type Abi = <[u8] as RefFromWasmAbi>::Abi; + type Anchor = Box; + + #[inline] + unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor { + mem::transmute::, Box>(>::from_abi(js)) + } +} + +if_std! { + use crate::JsValue; + + impl IntoWasmAbi for Box<[JsValue]> { + type Abi = WasmSlice; + + #[inline] + fn into_abi(self) -> WasmSlice { + let ptr = self.as_ptr(); + let len = self.len(); + mem::forget(self); + WasmSlice { + ptr: ptr.into_abi(), + len: len as u32, + } + } + } + + impl OptionIntoWasmAbi for Box<[JsValue]> { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl FromWasmAbi for Box<[JsValue]> { + type Abi = WasmSlice; + + #[inline] + unsafe fn from_abi(js: WasmSlice) -> Self { + let ptr = <*mut JsValue>::from_abi(js.ptr); + let len = js.len as usize; + Vec::from_raw_parts(ptr, len, len).into_boxed_slice() + } + } + + impl OptionFromWasmAbi for Box<[JsValue]> { + #[inline] + fn is_none(slice: &WasmSlice) -> bool { slice.ptr == 0 } + } + + impl IntoWasmAbi for Box<[T]> where T: JsObject { + type Abi = WasmSlice; + + #[inline] + fn into_abi(self) -> WasmSlice { + let ptr = self.as_ptr(); + let len = self.len(); + mem::forget(self); + WasmSlice { + ptr: ptr.into_abi(), + len: len as u32, + } + } + } + + impl OptionIntoWasmAbi for Box<[T]> where T: JsObject { + #[inline] + fn none() -> WasmSlice { null_slice() } + } + + impl FromWasmAbi for Box<[T]> where T: JsObject { + type Abi = WasmSlice; + + #[inline] + unsafe fn from_abi(js: WasmSlice) -> Self { + let ptr = <*mut JsValue>::from_abi(js.ptr); + let len = js.len as usize; + let vec: Vec = Vec::from_raw_parts(ptr, len, len).drain(..).map(|js_value| T::unchecked_from_js(js_value)).collect(); + return vec.into_boxed_slice(); + } + } + + impl OptionFromWasmAbi for Box<[T]> where T: JsObject { + #[inline] + fn is_none(slice: &WasmSlice) -> bool { slice.ptr == 0 } + } +} diff --git a/vendor/wasm-bindgen/src/convert/traits.rs b/vendor/wasm-bindgen/src/convert/traits.rs new file mode 100644 index 000000000..b9d12b4c8 --- /dev/null +++ b/vendor/wasm-bindgen/src/convert/traits.rs @@ -0,0 +1,131 @@ +use core::ops::{Deref, DerefMut}; + +use crate::describe::*; + +/// A trait for anything that can be converted into a type that can cross the +/// wasm ABI directly, eg `u32` or `f64`. +/// +/// This is the opposite operation as `FromWasmAbi` and `Ref[Mut]FromWasmAbi`. +pub trait IntoWasmAbi: WasmDescribe { + /// The wasm ABI type that this converts into when crossing the ABI + /// boundary. + type Abi: WasmAbi; + + /// Convert `self` into `Self::Abi` so that it can be sent across the wasm + /// ABI boundary. + fn into_abi(self) -> Self::Abi; +} + +/// A trait for anything that can be recovered by-value from the wasm ABI +/// boundary, eg a Rust `u8` can be recovered from the wasm ABI `u32` type. +/// +/// This is the by-value variant of the opposite operation as `IntoWasmAbi`. +pub trait FromWasmAbi: WasmDescribe { + /// The wasm ABI type that this converts from when coming back out from the + /// ABI boundary. + type Abi: WasmAbi; + + /// Recover a `Self` from `Self::Abi`. + /// + /// # Safety + /// + /// This is only safe to call when -- and implementations may assume that -- + /// the supplied `Self::Abi` was previously generated by a call to `::into_abi()` or the moral equivalent in JS. + unsafe fn from_abi(js: Self::Abi) -> Self; +} + +/// A trait for anything that can be recovered as some sort of shared reference +/// from the wasm ABI boundary. +/// +/// This is the shared reference variant of the opposite operation as +/// `IntoWasmAbi`. +pub trait RefFromWasmAbi: WasmDescribe { + /// The wasm ABI type references to `Self` are recovered from. + type Abi: WasmAbi; + + /// The type that holds the reference to `Self` for the duration of the + /// invocation of the function that has an `&Self` parameter. This is + /// required to ensure that the lifetimes don't persist beyond one function + /// call, and so that they remain anonymous. + type Anchor: Deref; + + /// Recover a `Self::Anchor` from `Self::Abi`. + /// + /// # Safety + /// + /// Same as `FromWasmAbi::from_abi`. + unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor; +} + +/// Dual of the `RefFromWasmAbi` trait, except for mutable references. +pub trait RefMutFromWasmAbi: WasmDescribe { + /// Same as `RefFromWasmAbi::Abi` + type Abi: WasmAbi; + /// Same as `RefFromWasmAbi::Anchor` + type Anchor: DerefMut; + /// Same as `RefFromWasmAbi::ref_from_abi` + unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor; +} + +/// Indicates that this type can be passed to JS as `Option`. +/// +/// This trait is used when implementing `IntoWasmAbi for Option`. +pub trait OptionIntoWasmAbi: IntoWasmAbi { + /// Returns an ABI instance indicating "none", which JS will interpret as + /// the `None` branch of this option. + /// + /// It should be guaranteed that the `IntoWasmAbi` can never produce the ABI + /// value returned here. + fn none() -> Self::Abi; +} + +/// Indicates that this type can be received from JS as `Option`. +/// +/// This trait is used when implementing `FromWasmAbi for Option`. +pub trait OptionFromWasmAbi: FromWasmAbi { + /// Tests whether the argument is a "none" instance. If so it will be + /// deserialized as `None`, and otherwise it will be passed to + /// `FromWasmAbi`. + fn is_none(abi: &Self::Abi) -> bool; +} + +/// An unsafe trait which represents types that are ABI-safe to pass via wasm +/// arguments. +/// +/// This is an unsafe trait to implement as there's no guarantee the type is +/// actually safe to transfer across the was boundary, it's up to you to +/// guarantee this so codegen works correctly. +pub unsafe trait WasmAbi {} + +unsafe impl WasmAbi for u32 {} +unsafe impl WasmAbi for i32 {} +unsafe impl WasmAbi for u64 {} +unsafe impl WasmAbi for i64 {} +unsafe impl WasmAbi for f32 {} +unsafe impl WasmAbi for f64 {} + +/// A trait representing how to interepret the return value of a function for +/// the wasm ABI. +/// +/// This is very similar to the `IntoWasmAbi` trait and in fact has a blanket +/// implementation for all implementors of the `IntoWasmAbi`. The primary use +/// case of this trait is to enable functions to return `Result`, interpreting +/// an error as "rethrow this to JS" +pub trait ReturnWasmAbi: WasmDescribe { + /// Same as `IntoWasmAbi::Abi` + type Abi: WasmAbi; + + /// Same as `IntoWasmAbi::into_abi`, except that it may throw and never + /// return in the case of `Err`. + fn return_abi(self) -> Self::Abi; +} + +impl ReturnWasmAbi for T { + type Abi = T::Abi; + + #[inline] + fn return_abi(self) -> Self::Abi { + self.into_abi() + } +} diff --git a/vendor/wasm-bindgen/src/describe.rs b/vendor/wasm-bindgen/src/describe.rs new file mode 100644 index 000000000..2b7c4b628 --- /dev/null +++ b/vendor/wasm-bindgen/src/describe.rs @@ -0,0 +1,192 @@ +//! This is an internal module, no stability guarantees are provided. Use at +//! your own risk. + +#![doc(hidden)] + +use crate::{Clamped, JsError, JsValue}; +use cfg_if::cfg_if; + +macro_rules! tys { + ($($a:ident)*) => (tys! { @ ($($a)*) 0 }); + (@ () $v:expr) => {}; + (@ ($a:ident $($b:ident)*) $v:expr) => { + pub const $a: u32 = $v; + tys!(@ ($($b)*) $v+1); + } +} + +// NB: this list must be kept in sync with `crates/cli-support/src/descriptor.rs` +tys! { + I8 + U8 + I16 + U16 + I32 + U32 + I64 + U64 + F32 + F64 + BOOLEAN + FUNCTION + CLOSURE + CACHED_STRING + STRING + REF + REFMUT + SLICE + VECTOR + EXTERNREF + NAMED_EXTERNREF + ENUM + RUST_STRUCT + CHAR + OPTIONAL + RESULT + UNIT + CLAMPED +} + +#[inline(always)] // see the wasm-interpreter crate +pub fn inform(a: u32) { + unsafe { super::__wbindgen_describe(a) } +} + +pub trait WasmDescribe { + fn describe(); +} + +macro_rules! simple { + ($($t:ident => $d:ident)*) => ($( + impl WasmDescribe for $t { + fn describe() { inform($d) } + } + )*) +} + +simple! { + i8 => I8 + u8 => U8 + i16 => I16 + u16 => U16 + i32 => I32 + u32 => U32 + i64 => I64 + u64 => U64 + isize => I32 + usize => U32 + f32 => F32 + f64 => F64 + bool => BOOLEAN + char => CHAR + JsValue => EXTERNREF +} + +cfg_if! { + if #[cfg(feature = "enable-interning")] { + simple! { + str => CACHED_STRING + } + + } else { + simple! { + str => STRING + } + } +} + +impl WasmDescribe for *const T { + fn describe() { + inform(I32) + } +} + +impl WasmDescribe for *mut T { + fn describe() { + inform(I32) + } +} + +impl WasmDescribe for [T] { + fn describe() { + inform(SLICE); + T::describe(); + } +} + +impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a T { + fn describe() { + inform(REF); + T::describe(); + } +} + +impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a mut T { + fn describe() { + inform(REFMUT); + T::describe(); + } +} + +if_std! { + use std::prelude::v1::*; + + cfg_if! { + if #[cfg(feature = "enable-interning")] { + simple! { + String => CACHED_STRING + } + + } else { + simple! { + String => STRING + } + } + } + + impl WasmDescribe for Box<[T]> { + fn describe() { + inform(VECTOR); + T::describe(); + } + } + + impl WasmDescribe for Vec where Box<[T]>: WasmDescribe { + fn describe() { + >::describe(); + } + } +} + +impl WasmDescribe for Option { + fn describe() { + inform(OPTIONAL); + T::describe(); + } +} + +impl WasmDescribe for () { + fn describe() { + inform(UNIT) + } +} + +impl> WasmDescribe for Result { + fn describe() { + inform(RESULT); + T::describe(); + } +} + +impl WasmDescribe for Clamped { + fn describe() { + inform(CLAMPED); + T::describe(); + } +} + +impl WasmDescribe for JsError { + fn describe() { + JsValue::describe(); + } +} diff --git a/vendor/wasm-bindgen/src/externref.rs b/vendor/wasm-bindgen/src/externref.rs new file mode 100644 index 000000000..a7e5f3ebc --- /dev/null +++ b/vendor/wasm-bindgen/src/externref.rs @@ -0,0 +1,184 @@ +use crate::JsValue; +use std::alloc::{self, Layout}; +use std::cell::Cell; +use std::mem; +use std::ptr; +use std::slice; +use std::vec::Vec; +use std::cmp::max; + +externs! { + #[link(wasm_import_module = "__wbindgen_externref_xform__")] + extern "C" { + fn __wbindgen_externref_table_grow(delta: usize) -> i32; + fn __wbindgen_externref_table_set_null(idx: usize) -> (); + } +} + +pub struct Slab { + data: Vec, + head: usize, + base: usize, +} + +impl Slab { + fn new() -> Slab { + Slab { + data: Vec::new(), + head: 0, + base: 0, + } + } + + fn alloc(&mut self) -> usize { + let ret = self.head; + if ret == self.data.len() { + let curr_len = self.data.len(); + if curr_len == self.data.capacity() { + let extra = max(128, curr_len); + let r = unsafe { __wbindgen_externref_table_grow(extra) }; + if r == -1 { + internal_error("table grow failure") + } + if self.base == 0 { + self.base = r as usize; + } else if self.base + self.data.len() != r as usize { + internal_error("someone else allocated table entires?") + } + + // poor man's `try_reserve_exact` until that's stable + unsafe { + let new_cap = self.data.capacity() + extra; + let size = mem::size_of::() * new_cap; + let align = mem::align_of::(); + let layout = match Layout::from_size_align(size, align) { + Ok(l) => l, + Err(_) => internal_error("size/align layout failure"), + }; + let ptr = alloc::alloc(layout) as *mut usize; + if ptr.is_null() { + internal_error("allocation failure"); + } + ptr::copy_nonoverlapping(self.data.as_ptr(), ptr, self.data.len()); + let new_vec = Vec::from_raw_parts(ptr, self.data.len(), new_cap); + let mut old = mem::replace(&mut self.data, new_vec); + old.set_len(0); + } + } + + // custom condition to ensure `push` below doesn't call `reserve` in + // optimized builds which pulls in lots of panic infrastructure + if self.data.len() >= self.data.capacity() { + internal_error("push should be infallible now") + } + self.data.push(ret + 1); + } + + // usage of `get_mut` thwarts panicking infrastructure in optimized + // builds + match self.data.get_mut(ret) { + Some(slot) => self.head = *slot, + None => internal_error("ret out of bounds"), + } + ret + self.base + } + + fn dealloc(&mut self, slot: usize) { + if slot < self.base { + internal_error("free reserved slot"); + } + let slot = slot - self.base; + + // usage of `get_mut` thwarts panicking infrastructure in optimized + // builds + match self.data.get_mut(slot) { + Some(ptr) => { + *ptr = self.head; + self.head = slot; + } + None => internal_error("slot out of bounds"), + } + } + + fn live_count(&self) -> u32 { + let mut free_count = 0; + let mut next = self.head; + while next < self.data.len() { + debug_assert!((free_count as usize) < self.data.len()); + free_count += 1; + match self.data.get(next) { + Some(n) => next = *n, + None => internal_error("slot out of bounds"), + }; + } + self.data.len() as u32 - free_count + } +} + +fn internal_error(msg: &str) -> ! { + if cfg!(debug_assertions) { + super::throw_str(msg) + } else { + std::process::abort() + } +} + +// Management of `externref` is always thread local since an `externref` value +// can't cross threads in wasm. Indices as a result are always thread-local. +std::thread_local!(pub static HEAP_SLAB: Cell = Cell::new(Slab::new())); + +#[no_mangle] +pub extern "C" fn __externref_table_alloc() -> usize { + HEAP_SLAB + .try_with(|slot| { + let mut slab = slot.replace(Slab::new()); + let ret = slab.alloc(); + slot.replace(slab); + ret + }) + .unwrap_or_else(|_| internal_error("tls access failure")) +} + +#[no_mangle] +pub extern "C" fn __externref_table_dealloc(idx: usize) { + if idx < super::JSIDX_RESERVED as usize { + return; + } + // clear this value from the table so while the table slot is un-allocated + // we don't keep around a strong reference to a potentially large object + unsafe { + __wbindgen_externref_table_set_null(idx); + } + HEAP_SLAB + .try_with(|slot| { + let mut slab = slot.replace(Slab::new()); + slab.dealloc(idx); + slot.replace(slab); + }) + .unwrap_or_else(|_| internal_error("tls access failure")) +} + +#[no_mangle] +pub unsafe extern "C" fn __externref_drop_slice(ptr: *mut JsValue, len: usize) { + for slot in slice::from_raw_parts_mut(ptr, len) { + __externref_table_dealloc(slot.idx as usize); + } +} + +// Implementation of `__wbindgen_externref_heap_live_count` for when we are using +// `externref` instead of the JS `heap`. +#[no_mangle] +pub unsafe extern "C" fn __externref_heap_live_count() -> u32 { + HEAP_SLAB + .try_with(|slot| { + let slab = slot.replace(Slab::new()); + let count = slab.live_count(); + slot.replace(slab); + count + }) + .unwrap_or_else(|_| internal_error("tls access failure")) +} + +// see comment in module above this in `link_mem_intrinsics` +#[inline(never)] +pub fn link_intrinsics() {} diff --git a/vendor/wasm-bindgen/src/lib.rs b/vendor/wasm-bindgen/src/lib.rs new file mode 100644 index 000000000..2ccb284b9 --- /dev/null +++ b/vendor/wasm-bindgen/src/lib.rs @@ -0,0 +1,1800 @@ +//! Runtime support for the `wasm-bindgen` tool +//! +//! This crate contains the runtime support necessary for `wasm-bindgen` the +//! attribute and tool. Crates pull in the `#[wasm_bindgen]` attribute through +//! this crate and this crate also provides JS bindings through the `JsValue` +//! interface. + +#![no_std] +#![allow(coherence_leak_check)] +#![doc(html_root_url = "https://docs.rs/wasm-bindgen/0.2")] + +use core::convert::TryFrom; +use core::fmt; +use core::marker; +use core::mem; +use core::ops::{ + Add, BitAnd, BitOr, BitXor, Deref, DerefMut, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub, +}; +use core::u32; + +use crate::convert::{FromWasmAbi, WasmSlice}; + +macro_rules! if_std { + ($($i:item)*) => ($( + #[cfg(feature = "std")] $i + )*) +} + +macro_rules! externs { + ($(#[$attr:meta])* extern "C" { $(fn $name:ident($($args:tt)*) -> $ret:ty;)* }) => ( + #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))] + $(#[$attr])* + extern "C" { + $(fn $name($($args)*) -> $ret;)* + } + + $( + #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))] + #[allow(unused_variables)] + unsafe extern fn $name($($args)*) -> $ret { + panic!("function not implemented on non-wasm32 targets") + } + )* + ) +} + +/// A module which is typically glob imported from: +/// +/// ``` +/// use wasm_bindgen::prelude::*; +/// ``` +pub mod prelude { + pub use crate::JsValue; + pub use crate::UnwrapThrowExt; + #[doc(hidden)] + pub use wasm_bindgen_macro::__wasm_bindgen_class_marker; + pub use wasm_bindgen_macro::wasm_bindgen; + + if_std! { + pub use crate::closure::Closure; + } + + pub use crate::JsError; +} + +pub mod convert; +pub mod describe; + +mod cast; +pub use crate::cast::{JsCast, JsObject}; +use convert::WasmOption; + +if_std! { + extern crate std; + use std::prelude::v1::*; + pub mod closure; + mod externref; + + mod cache; + pub use cache::intern::{intern, unintern}; +} + +/// Representation of an object owned by JS. +/// +/// A `JsValue` doesn't actually live in Rust right now but actually in a table +/// owned by the `wasm-bindgen` generated JS glue code. Eventually the ownership +/// will transfer into wasm directly and this will likely become more efficient, +/// but for now it may be slightly slow. +pub struct JsValue { + idx: u32, + _marker: marker::PhantomData<*mut u8>, // not at all threadsafe +} + +const JSIDX_OFFSET: u32 = 32; // keep in sync with js/mod.rs +const JSIDX_UNDEFINED: u32 = JSIDX_OFFSET + 0; +const JSIDX_NULL: u32 = JSIDX_OFFSET + 1; +const JSIDX_TRUE: u32 = JSIDX_OFFSET + 2; +const JSIDX_FALSE: u32 = JSIDX_OFFSET + 3; +const JSIDX_RESERVED: u32 = JSIDX_OFFSET + 4; + +impl JsValue { + /// The `null` JS value constant. + pub const NULL: JsValue = JsValue { + idx: JSIDX_NULL, + _marker: marker::PhantomData, + }; + + /// The `undefined` JS value constant. + pub const UNDEFINED: JsValue = JsValue { + idx: JSIDX_UNDEFINED, + _marker: marker::PhantomData, + }; + + /// The `true` JS value constant. + pub const TRUE: JsValue = JsValue { + idx: JSIDX_TRUE, + _marker: marker::PhantomData, + }; + + /// The `false` JS value constant. + pub const FALSE: JsValue = JsValue { + idx: JSIDX_FALSE, + _marker: marker::PhantomData, + }; + + #[inline] + fn _new(idx: u32) -> JsValue { + JsValue { + idx, + _marker: marker::PhantomData, + } + } + + /// Creates a new JS value which is a string. + /// + /// The utf-8 string provided is copied to the JS heap and the string will + /// be owned by the JS garbage collector. + #[inline] + pub fn from_str(s: &str) -> JsValue { + unsafe { JsValue::_new(__wbindgen_string_new(s.as_ptr(), s.len())) } + } + + /// Creates a new JS value which is a number. + /// + /// This function creates a JS value representing a number (a heap + /// allocated number) and returns a handle to the JS version of it. + #[inline] + pub fn from_f64(n: f64) -> JsValue { + unsafe { JsValue::_new(__wbindgen_number_new(n)) } + } + + /// Creates a new JS value which is a bigint from a string representing a number. + /// + /// This function creates a JS value representing a bigint (a heap + /// allocated large integer) and returns a handle to the JS version of it. + #[inline] + pub fn bigint_from_str(s: &str) -> JsValue { + unsafe { JsValue::_new(__wbindgen_bigint_from_str(s.as_ptr(), s.len())) } + } + + /// Creates a new JS value which is a boolean. + /// + /// This function creates a JS object representing a boolean (a heap + /// allocated boolean) and returns a handle to the JS version of it. + #[inline] + pub fn from_bool(b: bool) -> JsValue { + if b { + JsValue::TRUE + } else { + JsValue::FALSE + } + } + + /// Creates a new JS value representing `undefined`. + #[inline] + pub fn undefined() -> JsValue { + JsValue::UNDEFINED + } + + /// Creates a new JS value representing `null`. + #[inline] + pub fn null() -> JsValue { + JsValue::NULL + } + + /// Creates a new JS symbol with the optional description specified. + /// + /// This function will invoke the `Symbol` constructor in JS and return the + /// JS object corresponding to the symbol created. + pub fn symbol(description: Option<&str>) -> JsValue { + unsafe { + match description { + Some(description) => JsValue::_new(__wbindgen_symbol_named_new( + description.as_ptr(), + description.len(), + )), + None => JsValue::_new(__wbindgen_symbol_anonymous_new()), + } + } + } + + /// Creates a new `JsValue` from the JSON serialization of the object `t` + /// provided. + /// + /// **This function is deprecated**, due to [creating a dependency cycle in + /// some circumstances][dep-cycle-issue]. Use [`serde-wasm-bindgen`] or + /// [`gloo_utils::format::JsValueSerdeExt`] instead. + /// + /// [dep-cycle-issue]: https://github.com/rustwasm/wasm-bindgen/issues/2770 + /// [`serde-wasm-bindgen`]: https://docs.rs/serde-wasm-bindgen + /// [`gloo_utils::format::JsValueSerdeExt`]: https://docs.rs/gloo-utils/latest/gloo_utils/format/trait.JsValueSerdeExt.html + /// + /// This function will serialize the provided value `t` to a JSON string, + /// send the JSON string to JS, parse it into a JS object, and then return + /// a handle to the JS object. This is unlikely to be super speedy so it's + /// not recommended for large payloads, but it's a nice to have in some + /// situations! + /// + /// Usage of this API requires activating the `serde-serialize` feature of + /// the `wasm-bindgen` crate. + /// + /// # Errors + /// + /// Returns any error encountered when serializing `T` into JSON. + #[cfg(feature = "serde-serialize")] + #[deprecated = "causes dependency cycles, use `serde-wasm-bindgen` or `gloo_utils::format::JsValueSerdeExt` instead"] + pub fn from_serde(t: &T) -> serde_json::Result + where + T: serde::ser::Serialize + ?Sized, + { + let s = serde_json::to_string(t)?; + unsafe { Ok(JsValue::_new(__wbindgen_json_parse(s.as_ptr(), s.len()))) } + } + + /// Invokes `JSON.stringify` on this value and then parses the resulting + /// JSON into an arbitrary Rust value. + /// + /// **This function is deprecated**, due to [creating a dependency cycle in + /// some circumstances][dep-cycle-issue]. Use [`serde-wasm-bindgen`] or + /// [`gloo_utils::format::JsValueSerdeExt`] instead. + /// + /// [dep-cycle-issue]: https://github.com/rustwasm/wasm-bindgen/issues/2770 + /// [`serde-wasm-bindgen`]: https://docs.rs/serde-wasm-bindgen + /// [`gloo_utils::format::JsValueSerdeExt`]: https://docs.rs/gloo-utils/latest/gloo_utils/format/trait.JsValueSerdeExt.html + /// + /// This function will first call `JSON.stringify` on the `JsValue` itself. + /// The resulting string is then passed into Rust which then parses it as + /// JSON into the resulting value. + /// + /// Usage of this API requires activating the `serde-serialize` feature of + /// the `wasm-bindgen` crate. + /// + /// # Errors + /// + /// Returns any error encountered when parsing the JSON into a `T`. + #[cfg(feature = "serde-serialize")] + #[deprecated = "causes dependency cycles, use `serde-wasm-bindgen` or `gloo_utils::format::JsValueSerdeExt` instead"] + pub fn into_serde(&self) -> serde_json::Result + where + T: for<'a> serde::de::Deserialize<'a>, + { + unsafe { + let ret = __wbindgen_json_serialize(self.idx); + let s = String::from_abi(ret); + serde_json::from_str(&s) + } + } + + /// Returns the `f64` value of this JS value if it's an instance of a + /// number. + /// + /// If this JS value is not an instance of a number then this returns + /// `None`. + #[inline] + pub fn as_f64(&self) -> Option { + unsafe { FromWasmAbi::from_abi(__wbindgen_number_get(self.idx)) } + } + + /// Tests whether this JS value is a JS string. + #[inline] + pub fn is_string(&self) -> bool { + unsafe { __wbindgen_is_string(self.idx) == 1 } + } + + /// If this JS value is a string value, this function copies the JS string + /// value into wasm linear memory, encoded as UTF-8, and returns it as a + /// Rust `String`. + /// + /// To avoid the copying and re-encoding, consider the + /// `JsString::try_from()` function from [js-sys](https://docs.rs/js-sys) + /// instead. + /// + /// If this JS value is not an instance of a string or if it's not valid + /// utf-8 then this returns `None`. + /// + /// # UTF-16 vs UTF-8 + /// + /// JavaScript strings in general are encoded as UTF-16, but Rust strings + /// are encoded as UTF-8. This can cause the Rust string to look a bit + /// different than the JS string sometimes. For more details see the + /// [documentation about the `str` type][caveats] which contains a few + /// caveats about the encodings. + /// + /// [caveats]: https://rustwasm.github.io/docs/wasm-bindgen/reference/types/str.html + #[cfg(feature = "std")] + #[inline] + pub fn as_string(&self) -> Option { + unsafe { FromWasmAbi::from_abi(__wbindgen_string_get(self.idx)) } + } + + /// Returns the `bool` value of this JS value if it's an instance of a + /// boolean. + /// + /// If this JS value is not an instance of a boolean then this returns + /// `None`. + #[inline] + pub fn as_bool(&self) -> Option { + unsafe { + match __wbindgen_boolean_get(self.idx) { + 0 => Some(false), + 1 => Some(true), + _ => None, + } + } + } + + /// Tests whether this JS value is `null` + #[inline] + pub fn is_null(&self) -> bool { + unsafe { __wbindgen_is_null(self.idx) == 1 } + } + + /// Tests whether this JS value is `undefined` + #[inline] + pub fn is_undefined(&self) -> bool { + unsafe { __wbindgen_is_undefined(self.idx) == 1 } + } + + /// Tests whether the type of this JS value is `symbol` + #[inline] + pub fn is_symbol(&self) -> bool { + unsafe { __wbindgen_is_symbol(self.idx) == 1 } + } + + /// Tests whether `typeof self == "object" && self !== null`. + #[inline] + pub fn is_object(&self) -> bool { + unsafe { __wbindgen_is_object(self.idx) == 1 } + } + + /// Tests whether the type of this JS value is `function`. + #[inline] + pub fn is_function(&self) -> bool { + unsafe { __wbindgen_is_function(self.idx) == 1 } + } + + /// Tests whether the type of this JS value is `bigint`. + #[inline] + pub fn is_bigint(&self) -> bool { + unsafe { __wbindgen_is_bigint(self.idx) == 1 } + } + + /// Applies the unary `typeof` JS operator on a `JsValue`. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof) + #[inline] + pub fn js_typeof(&self) -> JsValue { + unsafe { JsValue::_new(__wbindgen_typeof(self.idx)) } + } + + /// Applies the binary `in` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in) + #[inline] + pub fn js_in(&self, obj: &JsValue) -> bool { + unsafe { __wbindgen_in(self.idx, obj.idx) == 1 } + } + + /// Tests whether the value is ["truthy"]. + /// + /// ["truthy"]: https://developer.mozilla.org/en-US/docs/Glossary/Truthy + #[inline] + pub fn is_truthy(&self) -> bool { + !self.is_falsy() + } + + /// Tests whether the value is ["falsy"]. + /// + /// ["falsy"]: https://developer.mozilla.org/en-US/docs/Glossary/Falsy + #[inline] + pub fn is_falsy(&self) -> bool { + unsafe { __wbindgen_is_falsy(self.idx) == 1 } + } + + /// Get a string representation of the JavaScript object for debugging. + #[cfg(feature = "std")] + fn as_debug_string(&self) -> String { + unsafe { + let mut ret = [0; 2]; + __wbindgen_debug_string(&mut ret, self.idx); + let data = Vec::from_raw_parts(ret[0] as *mut u8, ret[1], ret[1]); + String::from_utf8_unchecked(data) + } + } + + /// Compare two `JsValue`s for equality, using the `==` operator in JS. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality) + #[inline] + pub fn loose_eq(&self, other: &Self) -> bool { + unsafe { __wbindgen_jsval_loose_eq(self.idx, other.idx) != 0 } + } + + /// Applies the unary `~` JS operator on a `JsValue`. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT) + #[inline] + pub fn bit_not(&self) -> JsValue { + unsafe { JsValue::_new(__wbindgen_bit_not(self.idx)) } + } + + /// Applies the binary `>>>` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift) + #[inline] + pub fn unsigned_shr(&self, rhs: &Self) -> u32 { + unsafe { __wbindgen_unsigned_shr(self.idx, rhs.idx) } + } + + /// Applies the binary `/` JS operator on two `JsValue`s, catching and returning any `RangeError` thrown. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Division) + #[inline] + pub fn checked_div(&self, rhs: &Self) -> Self { + unsafe { JsValue::_new(__wbindgen_checked_div(self.idx, rhs.idx)) } + } + + /// Applies the binary `**` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation) + #[inline] + pub fn pow(&self, rhs: &Self) -> Self { + unsafe { JsValue::_new(__wbindgen_pow(self.idx, rhs.idx)) } + } + + /// Applies the binary `<` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than) + #[inline] + pub fn lt(&self, other: &Self) -> bool { + unsafe { __wbindgen_lt(self.idx, other.idx) == 1 } + } + + /// Applies the binary `<=` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal) + #[inline] + pub fn le(&self, other: &Self) -> bool { + unsafe { __wbindgen_le(self.idx, other.idx) == 1 } + } + + /// Applies the binary `>=` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal) + #[inline] + pub fn ge(&self, other: &Self) -> bool { + unsafe { __wbindgen_ge(self.idx, other.idx) == 1 } + } + + /// Applies the binary `>` JS operator on the two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than) + #[inline] + pub fn gt(&self, other: &Self) -> bool { + unsafe { __wbindgen_gt(self.idx, other.idx) == 1 } + } + + /// Applies the unary `+` JS operator on a `JsValue`. Can throw. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_plus) + #[inline] + pub fn unchecked_into_f64(&self) -> f64 { + unsafe { __wbindgen_as_number(self.idx) } + } +} + +impl PartialEq for JsValue { + /// Compares two `JsValue`s for equality, using the `===` operator in JS. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality) + #[inline] + fn eq(&self, other: &Self) -> bool { + unsafe { __wbindgen_jsval_eq(self.idx, other.idx) != 0 } + } +} + +impl PartialEq for JsValue { + #[inline] + fn eq(&self, other: &bool) -> bool { + self.as_bool() == Some(*other) + } +} + +impl PartialEq for JsValue { + #[inline] + fn eq(&self, other: &str) -> bool { + *self == JsValue::from_str(other) + } +} + +impl<'a> PartialEq<&'a str> for JsValue { + #[inline] + fn eq(&self, other: &&'a str) -> bool { + >::eq(self, other) + } +} + +if_std! { + impl PartialEq for JsValue { + #[inline] + fn eq(&self, other: &String) -> bool { + >::eq(self, other) + } + } + impl<'a> PartialEq<&'a String> for JsValue { + #[inline] + fn eq(&self, other: &&'a String) -> bool { + >::eq(self, other) + } + } +} + +macro_rules! forward_deref_unop { + (impl $imp:ident, $method:ident for $t:ty) => { + impl $imp for $t { + type Output = <&'static $t as $imp>::Output; + + #[inline] + fn $method(self) -> <&'static $t as $imp>::Output { + $imp::$method(&self) + } + } + }; +} + +macro_rules! forward_deref_binop { + (impl $imp:ident, $method:ident for $t:ty) => { + impl<'a> $imp<$t> for &'a $t { + type Output = <&'static $t as $imp<&'static $t>>::Output; + + #[inline] + fn $method(self, other: $t) -> <&'static $t as $imp<&'static $t>>::Output { + $imp::$method(self, &other) + } + } + + impl $imp<&$t> for $t { + type Output = <&'static $t as $imp<&'static $t>>::Output; + + #[inline] + fn $method(self, other: &$t) -> <&'static $t as $imp<&'static $t>>::Output { + $imp::$method(&self, other) + } + } + + impl $imp<$t> for $t { + type Output = <&'static $t as $imp<&'static $t>>::Output; + + #[inline] + fn $method(self, other: $t) -> <&'static $t as $imp<&'static $t>>::Output { + $imp::$method(&self, &other) + } + } + }; +} + +impl Not for &JsValue { + type Output = bool; + + /// Applies the `!` JS operator on a `JsValue`. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) + #[inline] + fn not(self) -> Self::Output { + JsValue::is_falsy(self) + } +} + +forward_deref_unop!(impl Not, not for JsValue); + +impl TryFrom for f64 { + type Error = JsValue; + + /// Applies the unary `+` JS operator on a `JsValue`. + /// Returns the numeric result on success, or the JS error value on error. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_plus) + #[inline] + fn try_from(val: JsValue) -> Result { + f64::try_from(&val) + } +} + +impl TryFrom<&JsValue> for f64 { + type Error = JsValue; + + /// Applies the unary `+` JS operator on a `JsValue`. + /// Returns the numeric result on success, or the JS error value on error. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_plus) + #[inline] + fn try_from(val: &JsValue) -> Result { + let jsval = unsafe { JsValue::_new(__wbindgen_try_into_number(val.idx)) }; + return match jsval.as_f64() { + Some(num) => Ok(num), + None => Err(jsval), + }; + } +} + +impl Neg for &JsValue { + type Output = JsValue; + + /// Applies the unary `-` JS operator on a `JsValue`. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unary_negation) + #[inline] + fn neg(self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_neg(self.idx)) } + } +} + +forward_deref_unop!(impl Neg, neg for JsValue); + +impl BitAnd for &JsValue { + type Output = JsValue; + + /// Applies the binary `&` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_AND) + #[inline] + fn bitand(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_bit_and(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl BitAnd, bitand for JsValue); + +impl BitOr for &JsValue { + type Output = JsValue; + + /// Applies the binary `|` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_OR) + #[inline] + fn bitor(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_bit_or(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl BitOr, bitor for JsValue); + +impl BitXor for &JsValue { + type Output = JsValue; + + /// Applies the binary `^` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR) + #[inline] + fn bitxor(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_bit_xor(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl BitXor, bitxor for JsValue); + +impl Shl for &JsValue { + type Output = JsValue; + + /// Applies the binary `<<` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Left_shift) + #[inline] + fn shl(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_shl(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Shl, shl for JsValue); + +impl Shr for &JsValue { + type Output = JsValue; + + /// Applies the binary `>>` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Right_shift) + #[inline] + fn shr(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_shr(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Shr, shr for JsValue); + +impl Add for &JsValue { + type Output = JsValue; + + /// Applies the binary `+` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Addition) + #[inline] + fn add(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_add(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Add, add for JsValue); + +impl Sub for &JsValue { + type Output = JsValue; + + /// Applies the binary `-` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Subtraction) + #[inline] + fn sub(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_sub(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Sub, sub for JsValue); + +impl Div for &JsValue { + type Output = JsValue; + + /// Applies the binary `/` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Division) + #[inline] + fn div(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_div(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Div, div for JsValue); + +impl Mul for &JsValue { + type Output = JsValue; + + /// Applies the binary `*` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Multiplication) + #[inline] + fn mul(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_mul(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Mul, mul for JsValue); + +impl Rem for &JsValue { + type Output = JsValue; + + /// Applies the binary `%` JS operator on two `JsValue`s. + /// + /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Remainder) + #[inline] + fn rem(self, rhs: Self) -> Self::Output { + unsafe { JsValue::_new(__wbindgen_rem(self.idx, rhs.idx)) } + } +} + +forward_deref_binop!(impl Rem, rem for JsValue); + +impl<'a> From<&'a str> for JsValue { + #[inline] + fn from(s: &'a str) -> JsValue { + JsValue::from_str(s) + } +} + +if_std! { + impl<'a> From<&'a String> for JsValue { + #[inline] + fn from(s: &'a String) -> JsValue { + JsValue::from_str(s) + } + } + + impl From for JsValue { + #[inline] + fn from(s: String) -> JsValue { + JsValue::from_str(&s) + } + } +} + +impl From for JsValue { + #[inline] + fn from(s: bool) -> JsValue { + JsValue::from_bool(s) + } +} + +impl<'a, T> From<&'a T> for JsValue +where + T: JsCast, +{ + #[inline] + fn from(s: &'a T) -> JsValue { + s.as_ref().clone() + } +} + +impl From> for JsValue +where + JsValue: From, +{ + #[inline] + fn from(s: Option) -> JsValue { + match s { + Some(s) => s.into(), + None => JsValue::undefined(), + } + } +} + +impl JsCast for JsValue { + // everything is a `JsValue`! + #[inline] + fn instanceof(_val: &JsValue) -> bool { + true + } + #[inline] + fn unchecked_from_js(val: JsValue) -> Self { + val + } + #[inline] + fn unchecked_from_js_ref(val: &JsValue) -> &Self { + val + } +} + +impl AsRef for JsValue { + #[inline] + fn as_ref(&self) -> &JsValue { + self + } +} + +macro_rules! numbers { + ($($n:ident)*) => ($( + impl PartialEq<$n> for JsValue { + #[inline] + fn eq(&self, other: &$n) -> bool { + self.as_f64() == Some(f64::from(*other)) + } + } + + impl From<$n> for JsValue { + #[inline] + fn from(n: $n) -> JsValue { + JsValue::from_f64(n.into()) + } + } + )*) +} + +numbers! { i8 u8 i16 u16 i32 u32 f32 f64 } + +macro_rules! big_numbers { + (|$arg:ident|, $($n:ident = $handle:expr,)*) => ($( + impl PartialEq<$n> for JsValue { + #[inline] + fn eq(&self, other: &$n) -> bool { + self == &JsValue::from(*other) + } + } + + impl From<$n> for JsValue { + #[inline] + fn from($arg: $n) -> JsValue { + unsafe { JsValue::_new($handle) } + } + } + )*) +} + +fn bigint_get_as_i64(v: &JsValue) -> Option { + unsafe { Option::from_abi(__wbindgen_bigint_get_as_i64(v.idx)) } +} + +macro_rules! try_from_for_num64 { + ($ty:ty) => { + impl TryFrom for $ty { + type Error = JsValue; + + #[inline] + fn try_from(v: JsValue) -> Result { + bigint_get_as_i64(&v) + // Reinterpret bits; ABI-wise this is safe to do and allows us to avoid + // having separate intrinsics per signed/unsigned types. + .map(|as_i64| as_i64 as Self) + // Double-check that we didn't truncate the bigint to 64 bits. + .filter(|as_self| v == *as_self) + // Not a bigint or not in range. + .ok_or(v) + } + } + }; +} + +try_from_for_num64!(i64); +try_from_for_num64!(u64); + +macro_rules! try_from_for_num128 { + ($ty:ty, $hi_ty:ty) => { + impl TryFrom for $ty { + type Error = JsValue; + + #[inline] + fn try_from(v: JsValue) -> Result { + // Truncate the bigint to 64 bits, this will give us the lower part. + let lo = match bigint_get_as_i64(&v) { + // The lower part must be interpreted as unsigned in both i128 and u128. + Some(lo) => lo as u64, + // Not a bigint. + None => return Err(v), + }; + // Now we know it's a bigint, so we can safely use `>> 64n` without + // worrying about a JS exception on type mismatch. + let hi = v >> JsValue::from(64_u64); + // The high part is the one we want checked against a 64-bit range. + // If it fits, then our original number is in the 128-bit range. + let hi = <$hi_ty>::try_from(hi)?; + Ok(Self::from(hi) << 64 | Self::from(lo)) + } + } + }; +} + +try_from_for_num128!(i128, i64); +try_from_for_num128!(u128, u64); + +big_numbers! { + |n|, + i64 = __wbindgen_bigint_from_i64(n), + u64 = __wbindgen_bigint_from_u64(n), + i128 = __wbindgen_bigint_from_i128((n >> 64) as i64, n as u64), + u128 = __wbindgen_bigint_from_u128((n >> 64) as u64, n as u64), +} + +// `usize` and `isize` have to be treated a bit specially, because we know that +// they're 32-bit but the compiler conservatively assumes they might be bigger. +// So, we have to manually forward to the `u32`/`i32` versions. +impl PartialEq for JsValue { + #[inline] + fn eq(&self, other: &usize) -> bool { + *self == (*other as u32) + } +} + +impl From for JsValue { + #[inline] + fn from(n: usize) -> Self { + Self::from(n as u32) + } +} + +impl PartialEq for JsValue { + #[inline] + fn eq(&self, other: &isize) -> bool { + *self == (*other as i32) + } +} + +impl From for JsValue { + #[inline] + fn from(n: isize) -> Self { + Self::from(n as i32) + } +} + +externs! { + #[link(wasm_import_module = "__wbindgen_placeholder__")] + extern "C" { + fn __wbindgen_object_clone_ref(idx: u32) -> u32; + fn __wbindgen_object_drop_ref(idx: u32) -> (); + + fn __wbindgen_string_new(ptr: *const u8, len: usize) -> u32; + fn __wbindgen_number_new(f: f64) -> u32; + fn __wbindgen_bigint_from_str(ptr: *const u8, len: usize) -> u32; + fn __wbindgen_bigint_from_i64(n: i64) -> u32; + fn __wbindgen_bigint_from_u64(n: u64) -> u32; + fn __wbindgen_bigint_from_i128(hi: i64, lo: u64) -> u32; + fn __wbindgen_bigint_from_u128(hi: u64, lo: u64) -> u32; + fn __wbindgen_symbol_named_new(ptr: *const u8, len: usize) -> u32; + fn __wbindgen_symbol_anonymous_new() -> u32; + + fn __wbindgen_externref_heap_live_count() -> u32; + + fn __wbindgen_is_null(idx: u32) -> u32; + fn __wbindgen_is_undefined(idx: u32) -> u32; + fn __wbindgen_is_symbol(idx: u32) -> u32; + fn __wbindgen_is_object(idx: u32) -> u32; + fn __wbindgen_is_function(idx: u32) -> u32; + fn __wbindgen_is_string(idx: u32) -> u32; + fn __wbindgen_is_bigint(idx: u32) -> u32; + fn __wbindgen_typeof(idx: u32) -> u32; + + fn __wbindgen_in(prop: u32, obj: u32) -> u32; + + fn __wbindgen_is_falsy(idx: u32) -> u32; + fn __wbindgen_as_number(idx: u32) -> f64; + fn __wbindgen_try_into_number(idx: u32) -> u32; + fn __wbindgen_neg(idx: u32) -> u32; + fn __wbindgen_bit_and(a: u32, b: u32) -> u32; + fn __wbindgen_bit_or(a: u32, b: u32) -> u32; + fn __wbindgen_bit_xor(a: u32, b: u32) -> u32; + fn __wbindgen_bit_not(idx: u32) -> u32; + fn __wbindgen_shl(a: u32, b: u32) -> u32; + fn __wbindgen_shr(a: u32, b: u32) -> u32; + fn __wbindgen_unsigned_shr(a: u32, b: u32) -> u32; + fn __wbindgen_add(a: u32, b: u32) -> u32; + fn __wbindgen_sub(a: u32, b: u32) -> u32; + fn __wbindgen_div(a: u32, b: u32) -> u32; + fn __wbindgen_checked_div(a: u32, b: u32) -> u32; + fn __wbindgen_mul(a: u32, b: u32) -> u32; + fn __wbindgen_rem(a: u32, b: u32) -> u32; + fn __wbindgen_pow(a: u32, b: u32) -> u32; + fn __wbindgen_lt(a: u32, b: u32) -> u32; + fn __wbindgen_le(a: u32, b: u32) -> u32; + fn __wbindgen_ge(a: u32, b: u32) -> u32; + fn __wbindgen_gt(a: u32, b: u32) -> u32; + + fn __wbindgen_number_get(idx: u32) -> WasmOption; + fn __wbindgen_boolean_get(idx: u32) -> u32; + fn __wbindgen_string_get(idx: u32) -> WasmSlice; + fn __wbindgen_bigint_get_as_i64(idx: u32) -> WasmOption; + + fn __wbindgen_debug_string(ret: *mut [usize; 2], idx: u32) -> (); + + fn __wbindgen_throw(a: *const u8, b: usize) -> !; + fn __wbindgen_rethrow(a: u32) -> !; + fn __wbindgen_error_new(a: *const u8, b: usize) -> u32; + + fn __wbindgen_cb_drop(idx: u32) -> u32; + + fn __wbindgen_describe(v: u32) -> (); + fn __wbindgen_describe_closure(a: u32, b: u32, c: u32) -> u32; + + fn __wbindgen_json_parse(ptr: *const u8, len: usize) -> u32; + fn __wbindgen_json_serialize(idx: u32) -> WasmSlice; + fn __wbindgen_jsval_eq(a: u32, b: u32) -> u32; + fn __wbindgen_jsval_loose_eq(a: u32, b: u32) -> u32; + + fn __wbindgen_not(idx: u32) -> u32; + + fn __wbindgen_memory() -> u32; + fn __wbindgen_module() -> u32; + fn __wbindgen_function_table() -> u32; + } +} + +impl Clone for JsValue { + #[inline] + fn clone(&self) -> JsValue { + unsafe { + let idx = __wbindgen_object_clone_ref(self.idx); + JsValue::_new(idx) + } + } +} + +#[cfg(feature = "std")] +impl fmt::Debug for JsValue { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "JsValue({})", self.as_debug_string()) + } +} + +#[cfg(not(feature = "std"))] +impl fmt::Debug for JsValue { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("JsValue") + } +} + +impl Drop for JsValue { + #[inline] + fn drop(&mut self) { + unsafe { + // We definitely should never drop anything in the stack area + debug_assert!(self.idx >= JSIDX_OFFSET, "free of stack slot {}", self.idx); + + // Otherwise if we're not dropping one of our reserved values, + // actually call the intrinsic. See #1054 for eventually removing + // this branch. + if self.idx >= JSIDX_RESERVED { + __wbindgen_object_drop_ref(self.idx); + } + } + } +} + +impl Default for JsValue { + fn default() -> Self { + Self::UNDEFINED + } +} + +/// Wrapper type for imported statics. +/// +/// This type is used whenever a `static` is imported from a JS module, for +/// example this import: +/// +/// ```ignore +/// #[wasm_bindgen] +/// extern "C" { +/// static console: JsValue; +/// } +/// ``` +/// +/// will generate in Rust a value that looks like: +/// +/// ```ignore +/// static console: JsStatic = ...; +/// ``` +/// +/// This type implements `Deref` to the inner type so it's typically used as if +/// it were `&T`. +#[cfg(feature = "std")] +pub struct JsStatic { + #[doc(hidden)] + pub __inner: &'static std::thread::LocalKey, +} + +#[cfg(feature = "std")] +impl Deref for JsStatic { + type Target = T; + fn deref(&self) -> &T { + // We know that our tls key is never overwritten after initialization, + // so it should be safe (on that axis at least) to hand out a reference + // that lives longer than the closure below. + // + // FIXME: this is not sound if we ever implement thread exit hooks on + // wasm, as the pointer will eventually be invalidated but you can get + // `&'static T` from this interface. We... probably need to deprecate + // and/or remove this interface nowadays. + unsafe { self.__inner.with(|ptr| &*(ptr as *const T)) } + } +} + +#[cold] +#[inline(never)] +#[deprecated(note = "renamed to `throw_str`")] +#[doc(hidden)] +pub fn throw(s: &str) -> ! { + throw_str(s) +} + +/// Throws a JS exception. +/// +/// This function will throw a JS exception with the message provided. The +/// function will not return as the wasm stack will be popped when the exception +/// is thrown. +/// +/// Note that it is very easy to leak memory with this function because this +/// function, unlike `panic!` on other platforms, **will not run destructors**. +/// It's recommended to return a `Result` where possible to avoid the worry of +/// leaks. +#[cold] +#[inline(never)] +pub fn throw_str(s: &str) -> ! { + unsafe { + __wbindgen_throw(s.as_ptr(), s.len()); + } +} + +/// Rethrow a JS exception +/// +/// This function will throw a JS exception with the JS value provided. This +/// function will not return and the wasm stack will be popped until the point +/// of entry of wasm itself. +/// +/// Note that it is very easy to leak memory with this function because this +/// function, unlike `panic!` on other platforms, **will not run destructors**. +/// It's recommended to return a `Result` where possible to avoid the worry of +/// leaks. +#[cold] +#[inline(never)] +pub fn throw_val(s: JsValue) -> ! { + unsafe { + let idx = s.idx; + mem::forget(s); + __wbindgen_rethrow(idx); + } +} + +/// Get the count of live `externref`s / `JsValue`s in `wasm-bindgen`'s heap. +/// +/// ## Usage +/// +/// This is intended for debugging and writing tests. +/// +/// To write a test that asserts against unnecessarily keeping `anref`s / +/// `JsValue`s alive: +/// +/// * get an initial live count, +/// +/// * perform some series of operations or function calls that should clean up +/// after themselves, and should not keep holding onto `externref`s / `JsValue`s +/// after completion, +/// +/// * get the final live count, +/// +/// * and assert that the initial and final counts are the same. +/// +/// ## What is Counted +/// +/// Note that this only counts the *owned* `externref`s / `JsValue`s that end up in +/// `wasm-bindgen`'s heap. It does not count borrowed `externref`s / `JsValue`s +/// that are on its stack. +/// +/// For example, these `JsValue`s are accounted for: +/// +/// ```ignore +/// #[wasm_bindgen] +/// pub fn my_function(this_is_counted: JsValue) { +/// let also_counted = JsValue::from_str("hi"); +/// assert!(wasm_bindgen::externref_heap_live_count() >= 2); +/// } +/// ``` +/// +/// While this borrowed `JsValue` ends up on the stack, not the heap, and +/// therefore is not accounted for: +/// +/// ```ignore +/// #[wasm_bindgen] +/// pub fn my_other_function(this_is_not_counted: &JsValue) { +/// // ... +/// } +/// ``` +pub fn externref_heap_live_count() -> u32 { + unsafe { __wbindgen_externref_heap_live_count() } +} + +#[doc(hidden)] +pub fn anyref_heap_live_count() -> u32 { + externref_heap_live_count() +} + +/// An extension trait for `Option` and `Result` for unwrapping the `T` +/// value, or throwing a JS error if it is not available. +/// +/// These methods should have a smaller code size footprint than the normal +/// `Option::unwrap` and `Option::expect` methods, but they are specific to +/// working with wasm and JS. +/// +/// On non-wasm32 targets, defaults to the normal unwrap/expect calls. +/// +/// # Example +/// +/// ``` +/// use wasm_bindgen::prelude::*; +/// +/// // If the value is `Option::Some` or `Result::Ok`, then we just get the +/// // contained `T` value. +/// let x = Some(42); +/// assert_eq!(x.unwrap_throw(), 42); +/// +/// let y: Option = None; +/// +/// // This call would throw an error to JS! +/// // +/// // y.unwrap_throw() +/// // +/// // And this call would throw an error to JS with a custom error message! +/// // +/// // y.expect_throw("woopsie daisy!") +/// ``` +pub trait UnwrapThrowExt: Sized { + /// Unwrap this `Option` or `Result`, but instead of panicking on failure, + /// throw an exception to JavaScript. + fn unwrap_throw(self) -> T { + self.expect_throw("`unwrap_throw` failed") + } + + /// Unwrap this container's `T` value, or throw an error to JS with the + /// given message if the `T` value is unavailable (e.g. an `Option` is + /// `None`). + fn expect_throw(self, message: &str) -> T; +} + +impl UnwrapThrowExt for Option { + fn expect_throw(self, message: &str) -> T { + if cfg!(all(target_arch = "wasm32", not(target_os = "emscripten"))) { + match self { + Some(val) => val, + None => throw_str(message), + } + } else { + self.expect(message) + } + } +} + +impl UnwrapThrowExt for Result +where + E: core::fmt::Debug, +{ + fn expect_throw(self, message: &str) -> T { + if cfg!(all(target_arch = "wasm32", not(target_os = "emscripten"))) { + match self { + Ok(val) => val, + Err(_) => throw_str(message), + } + } else { + self.expect(message) + } + } +} + +/// Returns a handle to this wasm instance's `WebAssembly.Module` +/// +/// Note that this is only available when the final wasm app is built with +/// `--target no-modules`, it's not recommended to rely on this API yet! This is +/// largely just an experimental addition to enable threading demos. Using this +/// may prevent your wasm module from building down the road. +#[doc(hidden)] +pub fn module() -> JsValue { + unsafe { JsValue::_new(__wbindgen_module()) } +} + +/// Returns a handle to this wasm instance's `WebAssembly.Memory` +pub fn memory() -> JsValue { + unsafe { JsValue::_new(__wbindgen_memory()) } +} + +/// Returns a handle to this wasm instance's `WebAssembly.Table` which is the +/// indirect function table used by Rust +pub fn function_table() -> JsValue { + unsafe { JsValue::_new(__wbindgen_function_table()) } +} + +#[doc(hidden)] +pub mod __rt { + use crate::JsValue; + use core::cell::{Cell, UnsafeCell}; + use core::ops::{Deref, DerefMut}; + + pub extern crate core; + #[cfg(feature = "std")] + pub extern crate std; + + #[macro_export] + #[doc(hidden)] + #[cfg(feature = "std")] + macro_rules! __wbindgen_if_not_std { + ($($i:item)*) => {}; + } + + #[macro_export] + #[doc(hidden)] + #[cfg(not(feature = "std"))] + macro_rules! __wbindgen_if_not_std { + ($($i:item)*) => ($($i)*) + } + + #[inline] + pub fn assert_not_null(s: *mut T) { + if s.is_null() { + throw_null(); + } + } + + #[cold] + #[inline(never)] + fn throw_null() -> ! { + super::throw_str("null pointer passed to rust"); + } + + /// A vendored version of `RefCell` from the standard library. + /// + /// Now why, you may ask, would we do that? Surely `RefCell` in libstd is + /// quite good. And you're right, it is indeed quite good! Functionally + /// nothing more is needed from `RefCell` in the standard library but for + /// now this crate is also sort of optimizing for compiled code size. + /// + /// One major factor to larger binaries in Rust is when a panic happens. + /// Panicking in the standard library involves a fair bit of machinery + /// (formatting, panic hooks, synchronization, etc). It's all worthwhile if + /// you need it but for something like `WasmRefCell` here we don't actually + /// need all that! + /// + /// This is just a wrapper around all Rust objects passed to JS intended to + /// guard accidental reentrancy, so this vendored version is intended solely + /// to not panic in libstd. Instead when it "panics" it calls our `throw` + /// function in this crate which raises an error in JS. + pub struct WasmRefCell { + borrow: Cell, + value: UnsafeCell, + } + + impl WasmRefCell { + pub fn new(value: T) -> WasmRefCell + where + T: Sized, + { + WasmRefCell { + value: UnsafeCell::new(value), + borrow: Cell::new(0), + } + } + + pub fn get_mut(&mut self) -> &mut T { + unsafe { &mut *self.value.get() } + } + + pub fn borrow(&self) -> Ref { + unsafe { + if self.borrow.get() == usize::max_value() { + borrow_fail(); + } + self.borrow.set(self.borrow.get() + 1); + Ref { + value: &*self.value.get(), + borrow: &self.borrow, + } + } + } + + pub fn borrow_mut(&self) -> RefMut { + unsafe { + if self.borrow.get() != 0 { + borrow_fail(); + } + self.borrow.set(usize::max_value()); + RefMut { + value: &mut *self.value.get(), + borrow: &self.borrow, + } + } + } + + pub fn into_inner(self) -> T + where + T: Sized, + { + self.value.into_inner() + } + } + + pub struct Ref<'b, T: ?Sized + 'b> { + value: &'b T, + borrow: &'b Cell, + } + + impl<'b, T: ?Sized> Deref for Ref<'b, T> { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + self.value + } + } + + impl<'b, T: ?Sized> Drop for Ref<'b, T> { + fn drop(&mut self) { + self.borrow.set(self.borrow.get() - 1); + } + } + + pub struct RefMut<'b, T: ?Sized + 'b> { + value: &'b mut T, + borrow: &'b Cell, + } + + impl<'b, T: ?Sized> Deref for RefMut<'b, T> { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + self.value + } + } + + impl<'b, T: ?Sized> DerefMut for RefMut<'b, T> { + #[inline] + fn deref_mut(&mut self) -> &mut T { + self.value + } + } + + impl<'b, T: ?Sized> Drop for RefMut<'b, T> { + fn drop(&mut self) { + self.borrow.set(0); + } + } + + fn borrow_fail() -> ! { + super::throw_str( + "recursive use of an object detected which would lead to \ + unsafe aliasing in rust", + ); + } + + if_std! { + use std::alloc::{alloc, dealloc, realloc, Layout}; + use std::mem; + + #[no_mangle] + pub extern "C" fn __wbindgen_malloc(size: usize) -> *mut u8 { + let align = mem::align_of::(); + if let Ok(layout) = Layout::from_size_align(size, align) { + unsafe { + if layout.size() > 0 { + let ptr = alloc(layout); + if !ptr.is_null() { + return ptr + } + } else { + return align as *mut u8 + } + } + } + + malloc_failure(); + } + + #[no_mangle] + pub unsafe extern "C" fn __wbindgen_realloc(ptr: *mut u8, old_size: usize, new_size: usize) -> *mut u8 { + let align = mem::align_of::(); + debug_assert!(old_size > 0); + debug_assert!(new_size > 0); + if let Ok(layout) = Layout::from_size_align(old_size, align) { + let ptr = realloc(ptr, layout, new_size); + if !ptr.is_null() { + return ptr + } + } + malloc_failure(); + } + + #[cold] + fn malloc_failure() -> ! { + if cfg!(debug_assertions) { + super::throw_str("invalid malloc request") + } else { + std::process::abort(); + } + } + + #[no_mangle] + pub unsafe extern "C" fn __wbindgen_free(ptr: *mut u8, size: usize) { + // This happens for zero-length slices, and in that case `ptr` is + // likely bogus so don't actually send this to the system allocator + if size == 0 { + return + } + let align = mem::align_of::(); + let layout = Layout::from_size_align_unchecked(size, align); + dealloc(ptr, layout); + } + } + + /// This is a curious function necessary to get wasm-bindgen working today, + /// and it's a bit of an unfortunate hack. + /// + /// The general problem is that somehow we need the above two symbols to + /// exist in the final output binary (__wbindgen_malloc and + /// __wbindgen_free). These symbols may be called by JS for various + /// bindings, so we for sure need to make sure they're exported. + /// + /// The problem arises, though, when what if no Rust code uses the symbols? + /// For all intents and purposes it looks to LLVM and the linker like the + /// above two symbols are dead code, so they're completely discarded! + /// + /// Specifically what happens is this: + /// + /// * The above two symbols are generated into some object file inside of + /// libwasm_bindgen.rlib + /// * The linker, LLD, will not load this object file unless *some* symbol + /// is loaded from the object. In this case, if the Rust code never calls + /// __wbindgen_malloc or __wbindgen_free then the symbols never get linked + /// in. + /// * Later when `wasm-bindgen` attempts to use the symbols they don't + /// exist, causing an error. + /// + /// This function is a weird hack for this problem. We inject a call to this + /// function in all generated code. Usage of this function should then + /// ensure that the above two intrinsics are translated. + /// + /// Due to how rustc creates object files this function (and anything inside + /// it) will be placed into the same object file as the two intrinsics + /// above. That means if this function is called and referenced we'll pull + /// in the object file and link the intrinsics. + /// + /// Ideas for how to improve this are most welcome! + pub fn link_mem_intrinsics() { + crate::externref::link_intrinsics(); + } + + static mut GLOBAL_EXNDATA: [u32; 2] = [0; 2]; + + #[no_mangle] + pub unsafe extern "C" fn __wbindgen_exn_store(idx: u32) { + debug_assert_eq!(GLOBAL_EXNDATA[0], 0); + GLOBAL_EXNDATA[0] = 1; + GLOBAL_EXNDATA[1] = idx; + } + + pub fn take_last_exception() -> Result<(), super::JsValue> { + unsafe { + let ret = if GLOBAL_EXNDATA[0] == 1 { + Err(super::JsValue::_new(GLOBAL_EXNDATA[1])) + } else { + Ok(()) + }; + GLOBAL_EXNDATA[0] = 0; + GLOBAL_EXNDATA[1] = 0; + return ret; + } + } + + /// An internal helper trait for usage in `#[wasm_bindgen]` on `async` + /// functions to convert the return value of the function to + /// `Result` which is what we'll return to JS (where an + /// error is a failed future). + pub trait IntoJsResult { + fn into_js_result(self) -> Result; + } + + impl IntoJsResult for () { + fn into_js_result(self) -> Result { + Ok(JsValue::undefined()) + } + } + + impl> IntoJsResult for T { + fn into_js_result(self) -> Result { + Ok(self.into()) + } + } + + impl, E: Into> IntoJsResult for Result { + fn into_js_result(self) -> Result { + match self { + Ok(e) => Ok(e.into()), + Err(e) => Err(e.into()), + } + } + } + + impl> IntoJsResult for Result<(), E> { + fn into_js_result(self) -> Result { + match self { + Ok(()) => Ok(JsValue::undefined()), + Err(e) => Err(e.into()), + } + } + } + + /// An internal helper trait for usage in `#[wasm_bindgen(start)]` + /// functions to throw the error (if it is `Err`). + pub trait Start { + fn start(self); + } + + impl Start for () { + #[inline] + fn start(self) {} + } + + impl> Start for Result<(), E> { + #[inline] + fn start(self) { + if let Err(e) = self { + crate::throw_val(e.into()); + } + } + } +} + +/// A wrapper type around slices and vectors for binding the `Uint8ClampedArray` +/// array in JS. +/// +/// If you need to invoke a JS API which must take `Uint8ClampedArray` array, +/// then you can define it as taking one of these types: +/// +/// * `Clamped<&[u8]>` +/// * `Clamped<&mut [u8]>` +/// * `Clamped>` +/// +/// All of these types will show up as `Uint8ClampedArray` in JS and will have +/// different forms of ownership in Rust. +#[derive(Copy, Clone, PartialEq, Debug, Eq)] +pub struct Clamped(pub T); + +impl Deref for Clamped { + type Target = T; + + fn deref(&self) -> &T { + &self.0 + } +} + +impl DerefMut for Clamped { + fn deref_mut(&mut self) -> &mut T { + &mut self.0 + } +} + +/// Convenience type for use on exported `fn() -> Result` functions, where you wish to +/// throw a JavaScript `Error` object. +/// +/// You can get wasm_bindgen to throw basic errors by simply returning +/// `Err(JsError::new("message"))` from such a function. +/// +/// For more complex error handling, `JsError` implements `From where T: std::error::Error` by +/// converting it to a string, so you can use it with `?`. Many Rust error types already do this, +/// and you can use [`thiserror`](https://crates.io/crates/thiserror) to derive Display +/// implementations easily or use any number of boxed error types that implement it already. +/// +/// +/// To allow JavaScript code to catch only your errors, you may wish to add a subclass of `Error` +/// in a JS module, and then implement `Into` directly on a type and instantiate that +/// subclass. In that case, you would not need `JsError` at all. +/// +/// ### Basic example +/// +/// ```rust,no_run +/// use wasm_bindgen::prelude::*; +/// +/// #[wasm_bindgen] +/// pub fn throwing_function() -> Result<(), JsError> { +/// Err(JsError::new("message")) +/// } +/// ``` +/// +/// ### Complex Example +/// +/// ```rust,no_run +/// use wasm_bindgen::prelude::*; +/// +/// #[derive(Debug, Clone)] +/// enum MyErrorType { +/// SomeError, +/// } +/// +/// use core::fmt; +/// impl std::error::Error for MyErrorType {} +/// impl fmt::Display for MyErrorType { +/// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +/// write!(f, "display implementation becomes the error message") +/// } +/// } +/// +/// fn internal_api() -> Result<(), MyErrorType> { +/// Err(MyErrorType::SomeError) +/// } +/// +/// #[wasm_bindgen] +/// pub fn throwing_function() -> Result<(), JsError> { +/// internal_api()?; +/// Ok(()) +/// } +/// +/// ``` +#[derive(Clone)] +pub struct JsError { + value: JsValue, +} + +impl JsError { + /// Construct a JavaScript `Error` object with a string message + #[inline] + pub fn new(s: &str) -> JsError { + Self { + value: unsafe { JsValue::_new(crate::__wbindgen_error_new(s.as_ptr(), s.len())) }, + } + } +} + +if_std! { + impl From for JsError + where + E: std::error::Error, + { + fn from(error: E) -> Self { + JsError::new(&error.to_string()) + } + } +} + +impl From for JsValue { + fn from(error: JsError) -> Self { + error.value + } +} -- cgit v1.2.3