Split JSValConvertible into two traits.

Later, we'll want to implement variations of the conversion *from* JS, but
not the conversion *to* JS.

1 files changed, 41 insertions, 14 deletions

diff --git a/src/components/script/dom/bindings/conversions.rs b/src/components/script/dom/bindings/conversions.rs
index 6b033225c85..bec1b135593 100644
--- a/src/components/script/dom/bindings/conversions.rs
+++ b/src/components/script/dom/bindings/conversions.rs
@@ -10,8 +10,11 @@ use js::{JSVAL_FALSE, JSVAL_TRUE, JSVAL_NULL};
 use js::glue::{RUST_INT_TO_JSVAL, RUST_UINT_TO_JSVAL, RUST_JS_NumberValue};
 use js::glue::{RUST_JSVAL_IS_NULL, RUST_JSVAL_IS_VOID};
 
-pub trait JSValConvertible {
+pub trait ToJSValConvertible {
     fn to_jsval(&self) -> JSVal;
+}
+
+pub trait FromJSValConvertible {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<Self, ()>;
 }
 
@@ -28,7 +31,7 @@ unsafe fn convert_from_jsval<T: Default>(
 }
 
 
-impl JSValConvertible for bool {
+impl ToJSValConvertible for bool {
     fn to_jsval(&self) -> JSVal {
         if *self {
             JSVAL_TRUE
@@ -36,150 +39,174 @@ impl JSValConvertible for bool {
             JSVAL_FALSE
         }
     }
+}
 
+impl FromJSValConvertible for bool {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<bool, ()> {
         let result = unsafe { convert_from_jsval(cx, val, JS_ValueToBoolean) };
         result.map(|b| b != 0)
     }
 }
 
-impl JSValConvertible for i8 {
+impl ToJSValConvertible for i8 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_INT_TO_JSVAL(*self as i32)
         }
     }
+}
 
+impl FromJSValConvertible for i8 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<i8, ()> {
         let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
         result.map(|v| v as i8)
     }
 }
 
-impl JSValConvertible for u8 {
+impl ToJSValConvertible for u8 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_INT_TO_JSVAL(*self as i32)
         }
     }
+}
 
+impl FromJSValConvertible for u8 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<u8, ()> {
         let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
         result.map(|v| v as u8)
     }
 }
 
-impl JSValConvertible for i16 {
+impl ToJSValConvertible for i16 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_INT_TO_JSVAL(*self as i32)
         }
     }
+}
 
+impl FromJSValConvertible for i16 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<i16, ()> {
         let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
         result.map(|v| v as i16)
     }
 }
 
-impl JSValConvertible for u16 {
+impl ToJSValConvertible for u16 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_UINT_TO_JSVAL(*self as u32)
         }
     }
+}
 
+impl FromJSValConvertible for u16 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<u16, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToUint16) }
     }
 }
 
-impl JSValConvertible for i32 {
+impl ToJSValConvertible for i32 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_INT_TO_JSVAL(*self)
         }
     }
+}
 
+impl FromJSValConvertible for i32 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<i32, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) }
     }
 }
 
-impl JSValConvertible for u32 {
+impl ToJSValConvertible for u32 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_UINT_TO_JSVAL(*self)
         }
     }
+}
 
+impl FromJSValConvertible for u32 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<u32, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToECMAUint32) }
     }
 }
 
-impl JSValConvertible for i64 {
+impl ToJSValConvertible for i64 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_JS_NumberValue(*self as f64)
         }
     }
+}
 
+impl FromJSValConvertible for i64 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<i64, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToInt64) }
     }
 }
 
-impl JSValConvertible for u64 {
+impl ToJSValConvertible for u64 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_JS_NumberValue(*self as f64)
         }
     }
+}
 
+impl FromJSValConvertible for u64 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<u64, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToUint64) }
     }
 }
 
-impl JSValConvertible for f32 {
+impl ToJSValConvertible for f32 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_JS_NumberValue(*self as f64)
         }
     }
+}
 
+impl FromJSValConvertible for f32 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<f32, ()> {
         let result = unsafe { convert_from_jsval(cx, val, JS_ValueToNumber) };
         result.map(|f| f as f32)
     }
 }
 
-impl JSValConvertible for f64 {
+impl ToJSValConvertible for f64 {
     fn to_jsval(&self) -> JSVal {
         unsafe {
             RUST_JS_NumberValue(*self)
         }
     }
+}
 
+impl FromJSValConvertible for f64 {
     fn from_jsval(cx: *JSContext, val: JSVal) -> Result<f64, ()> {
         unsafe { convert_from_jsval(cx, val, JS_ValueToNumber) }
     }
 }
 
-impl<T: JSValConvertible> JSValConvertible for Option<T> {
+impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> {
     fn to_jsval(&self) -> JSVal {
         match self {
             &Some(ref value) => value.to_jsval(),
             &None => JSVAL_NULL,
         }
     }
+}
 
+impl<T: FromJSValConvertible> FromJSValConvertible for Option<T> {
     fn from_jsval(cx: *JSContext, value: JSVal) -> Result<Option<T>, ()> {
         if unsafe { RUST_JSVAL_IS_NULL(value) != 0 || RUST_JSVAL_IS_VOID(value) != 0 } {
             Ok(None)
         } else {
-            let result: Result<T, ()> = JSValConvertible::from_jsval(cx, value);
+            let result: Result<T, ()> = FromJSValConvertible::from_jsval(cx, value);
             result.map(|v| Some(v))
         }
     }