Make the TryFrom trait more specific.

Author: richard-uk1

crates/backend/src/codegen.rs

@@ -888,9 +888,7 @@ impl ToTokens for ast::ImportEnum {
             }
 
             #[allow(clippy::all)]
-            impl wasm_bindgen::JsTryFrom<wasm_bindgen::JsValue> for #name {
-                type Error = wasm_bindgen::TypeMismatch;
-
+            impl wasm_bindgen::TryFromJsValue for #name {
                 fn try_from(value: wasm_bindgen::JsValue) -> Result<Self, wasm_bindgen::TypeMismatch> {
                     Ok(match value.as_string().ok_or(wasm_bindgen::TypeMismatch)?.as_str() {
                         #(#variant_strings => #variant_paths_ref,)*
@@ -1545,7 +1543,7 @@ fn iterable(rust_name: Option<&Ident>, iterable: &ast::Iterable) -> TokenStream
         ast::Iterable::TypedMap { key, value } => {
             quote! {
                 pub fn iter(&self) -> impl std::iter::Iterator<Item=(#key, #value)> {
-                    use wasm_bindgen::{UnwrapThrowExt, JsCast, JsTryFrom};
+                    use wasm_bindgen::{UnwrapThrowExt, JsCast, TryFromJsValue};
                     struct Iter(js_sys::Iterator);
 
                     impl Iterator for Iter {
@@ -1561,8 +1559,8 @@ fn iterable(rust_name: Option<&Ident>, iterable: &ast::Iterable) -> TokenStream
                             let key = entry.get(0);
                             let value = entry.get(1);
                             Some((
-                                    JsTryFrom::try_from(key).unwrap_throw(),
-                                    JsTryFrom::try_from(value).unwrap_throw()
+                                    TryFromJsValue::try_from(key).unwrap_throw(),
+                                    TryFromJsValue::try_from(value).unwrap_throw()
                                     ))
                         }
                     }
@@ -1574,7 +1572,7 @@ fn iterable(rust_name: Option<&Ident>, iterable: &ast::Iterable) -> TokenStream
         ast::Iterable::Typed(value) => {
             quote! {
                 pub fn iter(&self) -> impl std::iter::Iterator<Item=#value> {
-                    use wasm_bindgen::{UnwrapThrowExt, JsCast, JsTryFrom};
+                    use wasm_bindgen::{UnwrapThrowExt, JsCast, TryFromJsValue};
                     struct Iter(js_sys::Iterator);
 
                     impl Iterator for Iter {
@@ -1584,7 +1582,7 @@ fn iterable(rust_name: Option<&Ident>, iterable: &ast::Iterable) -> TokenStream
                             if next.done() {
                                 return None; // We discard the end value here.
                             }
-                            Some(JsTryFrom::try_from(next.value()).unwrap_throw())
+                            Some(TryFromJsValue::try_from(next.value()).unwrap_throw())
                         }
                     }
 

crates/web-sys/tests/wasm/headers.rs

@@ -44,4 +44,3 @@ fn headers() {
         assert_eq!(value, "text/plain");
     }
 }
-

src/lib.rs

@@ -40,12 +40,9 @@ macro_rules! externs {
     )
 }
 
-pub trait JsTryFrom<T>: Sized {
-    /// The type returned in the event of a conversion error.
-    type Error;
-
+pub trait TryFromJsValue: Sized {
     /// Performs the conversion.
-    fn try_from(value: T) -> Result<Self, Self::Error>;
+    fn try_from(value: JsValue) -> Result<Self, TypeMismatch>;
 }
 
 /// A module which is typically glob imported from:
@@ -448,29 +445,24 @@ where
     }
 }
 
-impl JsTryFrom<JsValue> for bool {
-    type Error = TypeMismatch;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+impl TryFromJsValue for bool {
+    fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
         value.as_bool().ok_or(TypeMismatch)
     }
 }
 
-impl JsTryFrom<JsValue> for String {
-    type Error = TypeMismatch;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+impl TryFromJsValue for String {
+    fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
         value.as_string().ok_or(TypeMismatch)
     }
 }
 
-impl<T> JsTryFrom<JsValue> for Option<T>
+// This would not be possible if we used `std::convert::TryFrom`.
+impl<T> TryFromJsValue for Option<T>
 where
-    T: JsTryFrom<JsValue, Error = TypeMismatch>,
+    T: TryFromJsValue,
 {
-    type Error = TypeMismatch;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+    fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
         if value.is_null() || value.is_undefined() {
             return Ok(None);
         } else {
@@ -479,13 +471,11 @@ where
     }
 }
 
-impl<T> JsTryFrom<JsValue> for T
+impl<T> TryFromJsValue for T
 where
     T: JsCast,
 {
-    type Error = TypeMismatch;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+    fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
         value.dyn_into().map_err(|_| TypeMismatch)
     }
 }
@@ -538,12 +528,17 @@ numbers! { i8 u8 i16 u16 i32 u32 f32 f64 }
 
 macro_rules! integers {
     ($($n:ident)*) => ($(
-        impl JsTryFrom<JsValue> for $n {
-            type Error = TypeMismatch;
-
-            fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        impl TryFromJsValue for $n {
+            fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
+                const MAX_SAFE_JS_INT: f64 = 9_007_199_254_740_991.0; //(2^53 - 1)
                 let value = value.as_f64().ok_or(TypeMismatch)?;
-                if value > $n::max_value() as f64 || value < $n::min_value() as f64 {
+                // https://doc.rust-lang.org/1.30.0/book/first-edition/casting-between-types.html
+                if ! value.is_normal()
+                    || value > $n::max_value() as f64
+                    || value < $n::min_value() as f64
+                    || value.abs() > MAX_SAFE_JS_INT
+                    || value != value.floor()
+                {
                     return Err(TypeMismatch);
                 }
                 Ok(value as $n)
@@ -556,10 +551,8 @@ integers! { i8 u8 i16 u16 i32 u32 }
 
 macro_rules! floats {
     ($($n:ident)*) => ($(
-        impl JsTryFrom<JsValue> for $n {
-            type Error = TypeMismatch;
-
-            fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        impl TryFromJsValue for $n {
+            fn try_from(value: JsValue) -> Result<Self, TypeMismatch> {
                 let value = value.as_f64().ok_or(TypeMismatch)?;
                 Ok(value as $n)
             }