Remove the need for rust-mozjs to use unstable Rust features

components/canvas_traits/webgl.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use euclid::Size2D;
-use nonzero::NonZeroU32;
+use nonzero::NonZero;
 use offscreen_gl_context::{GLContextAttributes, GLLimits};
 use std::fmt;
 use webrender_api;
@@ -242,13 +242,13 @@ pub enum WebGLCommand {
 macro_rules! define_resource_id_struct {
     ($name:ident) => {
         #[derive(Clone, Copy, Eq, Hash, PartialEq)]
-        pub struct $name(NonZeroU32);
+        pub struct $name(NonZero<u32>);
 
         impl $name {
             #[allow(unsafe_code)]
             #[inline]
             pub unsafe fn new(id: u32) -> Self {
-                $name(NonZeroU32::new_unchecked(id))
+                $name(NonZero::new_unchecked(id))
             }
 
             #[inline]

components/compositing/compositor.rs

@@ -13,7 +13,7 @@ use image::{DynamicImage, ImageFormat, RgbImage};
 use ipc_channel::ipc::{self, IpcSharedMemory};
 use msg::constellation_msg::{PipelineId, PipelineIndex, PipelineNamespaceId};
 use net_traits::image::base::{Image, PixelFormat};
-use nonzero::NonZeroU32;
+use nonzero::NonZero;
 use profile_traits::time::{self, ProfilerCategory, profile};
 use script_traits::{AnimationState, AnimationTickType, ConstellationControlMsg};
 use script_traits::{ConstellationMsg, LayoutControlMsg, MouseButton};
@@ -62,7 +62,7 @@ impl ConvertPipelineIdFromWebRender for webrender_api::PipelineId {
     fn from_webrender(&self) -> PipelineId {
         PipelineId {
             namespace_id: PipelineNamespaceId(self.0),
-            index: PipelineIndex(NonZeroU32::new(self.1).expect("Webrender pipeline zero?")),
+            index: PipelineIndex(NonZero::new(self.1).expect("Webrender pipeline zero?")),
         }
     }
 }

components/layout_thread/dom_wrapper.rs

@@ -36,7 +36,7 @@ use html5ever::{LocalName, Namespace};
 use layout::data::StyleAndLayoutData;
 use layout::wrapper::GetRawData;
 use msg::constellation_msg::{BrowsingContextId, PipelineId};
-use nonzero::NonZeroUsize;
+use nonzero::NonZero;
 use range::Range;
 use script::layout_exports::{CAN_BE_FRAGMENTED, HAS_DIRTY_DESCENDANTS, IS_IN_DOC};
 use script::layout_exports::{CharacterDataTypeId, ElementTypeId, HTMLElementTypeId, NodeTypeId};
@@ -235,8 +235,7 @@ impl<'ln> LayoutNode for ServoLayoutNode<'ln> {
             let ptr: *mut StyleAndLayoutData =
                 Box::into_raw(Box::new(StyleAndLayoutData::new()));
             let opaque = OpaqueStyleAndLayoutData {
-                ptr: NonZeroUsize::new_unchecked(ptr as usize),
-                phantom: PhantomData,
+                ptr: NonZero::new_unchecked(ptr as *mut StyleData),
             };
             self.init_style_and_layout_data(opaque);
         };

components/msg/constellation_msg.rs

@@ -5,7 +5,7 @@
 //! The high-level interface from script to constellation. Using this abstract interface helps
 //! reduce coupling between these two components.
 
-use nonzero::NonZeroU32;
+use nonzero::NonZero;
 use std::cell::Cell;
 use std::fmt;
 use webrender_api;
@@ -195,9 +195,9 @@ impl PipelineNamespace {
         });
     }
 
-    fn next_index(&mut self) -> NonZeroU32 {
+    fn next_index(&mut self) -> NonZero<u32> {
         self.index += 1;
-        NonZeroU32::new(self.index).expect("pipeline id index wrapped!")
+        NonZero::new(self.index).expect("pipeline id index wrapped!")
     }
 
     fn next_pipeline_id(&mut self) -> PipelineId {
@@ -221,7 +221,7 @@ thread_local!(pub static PIPELINE_NAMESPACE: Cell<Option<PipelineNamespace>> = C
 pub struct PipelineNamespaceId(pub u32);
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-pub struct PipelineIndex(pub NonZeroU32);
+pub struct PipelineIndex(pub NonZero<u32>);
 known_heap_size!(0, PipelineIndex);
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, HeapSizeOf, Ord, PartialEq, PartialOrd, Serialize)]
@@ -264,7 +264,7 @@ impl fmt::Display for PipelineId {
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-pub struct BrowsingContextIndex(pub NonZeroU32);
+pub struct BrowsingContextIndex(pub NonZero<u32>);
 known_heap_size!(0, BrowsingContextIndex);
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, HeapSizeOf, Ord, PartialEq, PartialOrd, Serialize)]
@@ -340,13 +340,13 @@ impl PartialEq<BrowsingContextId> for TopLevelBrowsingContextId {
 pub const TEST_NAMESPACE: PipelineNamespaceId = PipelineNamespaceId(1234);
 #[allow(unsafe_code)]
 #[cfg(feature = "unstable")]
-pub const TEST_PIPELINE_INDEX: PipelineIndex = unsafe { PipelineIndex(NonZeroU32::new_unchecked(5678)) };
+pub const TEST_PIPELINE_INDEX: PipelineIndex = unsafe { PipelineIndex(NonZero::new_unchecked(5678)) };
 #[cfg(feature = "unstable")]
 pub const TEST_PIPELINE_ID: PipelineId = PipelineId { namespace_id: TEST_NAMESPACE, index: TEST_PIPELINE_INDEX };
 #[allow(unsafe_code)]
 #[cfg(feature = "unstable")]
 pub const TEST_BROWSING_CONTEXT_INDEX: BrowsingContextIndex =
-    unsafe { BrowsingContextIndex(NonZeroU32::new_unchecked(8765)) };
+    unsafe { BrowsingContextIndex(NonZero::new_unchecked(8765)) };
 #[cfg(feature = "unstable")]
 pub const TEST_BROWSING_CONTEXT_ID: BrowsingContextId =
     BrowsingContextId { namespace_id: TEST_NAMESPACE, index: TEST_BROWSING_CONTEXT_INDEX };

components/nonzero/lib.rs

@@ -9,113 +9,133 @@
 #![cfg_attr(feature = "unstable", feature(const_fn))]
 #![cfg_attr(feature = "unstable", feature(const_nonzero_new))]
 
-#[macro_use]
+#[cfg_attr(not(feature = "unstable"), macro_use)]
 extern crate serde;
 
 pub use imp::*;
 
 #[cfg(feature = "unstable")]
 mod imp {
     extern crate core;
-    use self::core::nonzero::NonZero;
+    use self::core::nonzero::NonZero as CoreNonZero;
+    use serde::{Serialize, Serializer, Deserialize, Deserializer};
 
-    #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-    pub struct NonZeroU32(NonZero<u32>);
+    pub use self::core::nonzero::Zeroable;
 
-    #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-    pub struct NonZeroUsize(NonZero<usize>);
+    #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+    pub struct NonZero<T: Zeroable>(CoreNonZero<T>);
+
+    impl<T: Zeroable> NonZero<T> {
+        #[inline]
+        pub const unsafe fn new_unchecked(x: T) -> Self {
+            NonZero(CoreNonZero::new_unchecked(x))
+        }
+
+        #[inline]
+        pub fn new(x: T) -> Option<Self> {
+            CoreNonZero::new(x).map(NonZero)
+        }
+
+        #[inline]
+        pub fn get(self) -> T {
+            self.0.get()
+        }
+    }
 
-    impl NonZeroU32 {
-        #[inline] pub const unsafe fn new_unchecked(x: u32) -> Self { NonZeroU32(NonZero::new_unchecked(x)) }
-        #[inline] pub fn new(x: u32) -> Option<Self> { NonZero::new(x).map(NonZeroU32) }
-        #[inline] pub fn get(self) -> u32 { self.0.get() }
+    // Not using derive because of the additional Clone bound required by the inner impl
+
+    impl<T> Serialize for NonZero<T>
+    where
+        T: Serialize + Zeroable + Clone,
+    {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            self.0.serialize(serializer)
+        }
     }
 
-    impl NonZeroUsize {
-        #[inline] pub const unsafe fn new_unchecked(x: usize) -> Self { NonZeroUsize(NonZero::new_unchecked(x)) }
-        #[inline] pub fn new(x: usize) -> Option<Self> { NonZero::new(x).map(NonZeroUsize) }
-        #[inline] pub fn get(self) -> usize { self.0.get() }
+    impl<'de, T> Deserialize<'de> for NonZero<T>
+    where
+        T: Deserialize<'de> + Zeroable,
+    {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            CoreNonZero::deserialize(deserializer).map(NonZero)
+        }
     }
 }
 
 #[cfg(not(feature = "unstable"))]
 mod imp {
-    use std::cmp;
-    use std::hash;
-
     #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
-    pub struct NonZeroU32(u32);
+    pub struct NonZero<T: Zeroable>(T);
 
-    impl NonZeroU32 {
+    impl<T: Zeroable> NonZero<T> {
         #[inline]
-        pub fn new(x: u32) -> Option<Self> {
-            if x != 0 {
-                Some(NonZeroU32(x))
-            } else {
-                None
-            }
+        pub unsafe fn new_unchecked(x: T) -> Self {
+            NonZero(x)
         }
 
         #[inline]
-        pub unsafe fn new_unchecked(x: u32) -> Self {
-            NonZeroU32(x)
-        }
-
-        #[inline]
-        pub fn get(self) -> u32 {
-            self.0
-        }
-    }
-
-    #[derive(Clone, Copy, Debug, Eq)]
-    pub struct NonZeroUsize(&'static ());
-
-    impl NonZeroUsize {
-        #[inline]
-        pub fn new(x: usize) -> Option<Self> {
-            if x != 0 {
-                Some(unsafe { Self::new_unchecked(x) })
-            } else {
+        pub fn new(x: T) -> Option<Self> {
+            if x.is_zero() {
                 None
+            } else {
+                Some(NonZero(x))
             }
         }
 
         #[inline]
-        pub unsafe fn new_unchecked(x: usize) -> Self {
-            NonZeroUsize(&*(x as *const ()))
+        pub fn get(self) -> T {
+            self.0
         }
+    }
 
-        #[inline]
-        pub fn get(self) -> usize {
-            self.0 as *const () as usize
-        }
+    /// Unsafe trait to indicate what types are usable with the NonZero struct
+    pub unsafe trait Zeroable {
+        /// Whether this value is zero
+        fn is_zero(&self) -> bool;
     }
 
-    impl PartialEq for NonZeroUsize {
-        #[inline]
-        fn eq(&self, other: &Self) -> bool {
-            self.get() == other.get()
+    macro_rules! impl_zeroable_for_pointer_types {
+        ( $( $Ptr: ty )+ ) => {
+            $(
+                /// For fat pointers to be considered "zero", only the "data" part needs to be null.
+                unsafe impl<T: ?Sized> Zeroable for $Ptr {
+                    #[inline]
+                    fn is_zero(&self) -> bool {
+                        // Cast because `is_null` is only available on thin pointers
+                        (*self as *mut u8).is_null()
+                    }
+                }
+            )+
         }
     }
 
-    impl PartialOrd for NonZeroUsize {
-        #[inline]
-        fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
-            self.get().partial_cmp(&other.get())
+    macro_rules! impl_zeroable_for_integer_types {
+        ( $( $Int: ty )+ ) => {
+            $(
+                unsafe impl Zeroable for $Int {
+                    #[inline]
+                    fn is_zero(&self) -> bool {
+                        *self == 0
+                    }
+                }
+            )+
         }
     }
 
-    impl Ord for NonZeroUsize {
-        #[inline]
-        fn cmp(&self, other: &Self) -> cmp::Ordering {
-            self.get().cmp(&other.get())
-        }
+    impl_zeroable_for_pointer_types! {
+        *const T
+        *mut T
     }
 
-    impl hash::Hash for NonZeroUsize {
-        #[inline]
-        fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
-            self.get().hash(hasher)
-        }
+    impl_zeroable_for_integer_types! {
+        usize u8 u16 u32 u64
+        isize i8 i16 i32 i64
     }
 }

components/remutex/lib.rs

@@ -14,7 +14,7 @@ extern crate nonzero;
 #[macro_use] extern crate lazy_static;
 #[macro_use] extern crate log;
 
-use nonzero::NonZeroUsize;
+use nonzero::NonZero;
 use std::cell::{Cell, UnsafeCell};
 use std::ops::Deref;
 use std::sync::{LockResult, Mutex, MutexGuard, PoisonError, TryLockError, TryLockResult};
@@ -25,15 +25,15 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 // TODO: can we use the thread-id crate for this?
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ThreadId(NonZeroUsize);
+pub struct ThreadId(NonZero<usize>);
 
 lazy_static!{ static ref THREAD_COUNT: AtomicUsize = AtomicUsize::new(1); }
 
 impl ThreadId {
     #[allow(unsafe_code)]
     fn new() -> ThreadId {
         let number = THREAD_COUNT.fetch_add(1, Ordering::SeqCst);
-        ThreadId(NonZeroUsize::new(number).unwrap())
+        ThreadId(NonZero::new(number).unwrap())
     }
     pub fn current() -> ThreadId {
         THREAD_ID.with(|tls| tls.clone())
@@ -57,13 +57,13 @@ impl AtomicOptThreadId {
     #[allow(unsafe_code)]
     pub fn load(&self, ordering: Ordering) -> Option<ThreadId> {
         let number = self.0.load(ordering);
-        NonZeroUsize::new(number).map(ThreadId)
+        NonZero::new(number).map(ThreadId)
     }
     #[allow(unsafe_code)]
     pub fn swap(&self, value: Option<ThreadId>, ordering: Ordering) -> Option<ThreadId> {
         let number = value.map(|id| id.0.get()).unwrap_or(0);
         let number = self.0.swap(number, ordering);
-        NonZeroUsize::new(number).map(ThreadId)
+        NonZero::new(number).map(ThreadId)
     }
 }
 

components/script/Cargo.toml

@@ -13,6 +13,7 @@ path = "lib.rs"
 
 [features]
 debugmozjs = ['js/debugmozjs']
+unstable = []
 
 [build-dependencies]
 cmake = "0.1"
@@ -61,6 +62,7 @@ mime = "0.2.1"
 mime_guess = "1.8.0"
 msg = {path = "../msg"}
 net_traits = {path = "../net_traits"}
+nonzero = {path = "../nonzero"}
 num-traits = "0.1.32"
 offscreen_gl_context = { version = "0.11", features = ["serde"] }
 open = "1.1.1"