Replace NonZero<*{const,mut} _> with std::ptr::NonNull

components/script/dom/bindings/root.rs

@@ -34,7 +34,6 @@ use js::jsapi::{JSObject, JSTracer, Heap};
 use js::rust::GCMethods;
 use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use mitochondria::OnceCell;
-use nonzero::NonZero;
 use script_layout_interface::TrustedNodeAddress;
 use std::cell::{Cell, UnsafeCell};
 use std::default::Default;
@@ -312,7 +311,7 @@ impl<'root, T: RootedReference<'root> + 'root> RootedReference<'root> for Option
 /// This should only be used as a field in other DOM objects.
 #[must_root]
 pub struct Dom<T> {
-    ptr: NonZero<*const T>,
+    ptr: ptr::NonNull<T>,
 }
 
 // Dom<T> is similar to Rc<T>, in that it's not always clear how to avoid double-counting.
@@ -339,7 +338,7 @@ impl<T: DomObject> Dom<T> {
     pub fn from_ref(obj: &T) -> Dom<T> {
         debug_assert!(thread_state::get().is_script());
         Dom {
-            ptr: unsafe { NonZero::new_unchecked(&*obj) },
+            ptr: ptr::NonNull::from(obj),
         }
     }
 }
@@ -351,7 +350,7 @@ impl<T: DomObject> Deref for Dom<T> {
         debug_assert!(thread_state::get().is_script());
         // We can only have &Dom<T> from a rooted thing, so it's safe to deref
         // it to &T.
-        unsafe { &*self.ptr.get() }
+        unsafe { &*self.ptr.as_ptr() }
     }
 }
 
@@ -366,7 +365,7 @@ unsafe impl<T: DomObject> JSTraceable for Dom<T> {
 
         trace_reflector(trc,
                         trace_info,
-                        (*self.ptr.get()).reflector());
+                        (*self.ptr.as_ptr()).reflector());
     }
 }
 
@@ -374,7 +373,7 @@ unsafe impl<T: DomObject> JSTraceable for Dom<T> {
 /// traits must be implemented on this.
 #[allow_unrooted_interior]
 pub struct LayoutDom<T> {
-    ptr: NonZero<*const T>,
+    ptr: ptr::NonNull<T>,
 }
 
 impl<T: Castable> LayoutDom<T> {
@@ -384,9 +383,9 @@ impl<T: Castable> LayoutDom<T> {
               T: DerivedFrom<U>
     {
         debug_assert!(thread_state::get().is_layout());
-        let ptr: *const T = self.ptr.get();
+        let ptr: *mut T = self.ptr.as_ptr();
         LayoutDom {
-            ptr: unsafe { NonZero::new_unchecked(ptr as *const U) },
+            ptr: unsafe { ptr::NonNull::new_unchecked(ptr as *mut U) },
         }
     }
 
@@ -397,9 +396,9 @@ impl<T: Castable> LayoutDom<T> {
         debug_assert!(thread_state::get().is_layout());
         unsafe {
             if (*self.unsafe_get()).is::<U>() {
-                let ptr: *const T = self.ptr.get();
+                let ptr: *mut T = self.ptr.as_ptr();
                 Some(LayoutDom {
-                    ptr: NonZero::new_unchecked(ptr as *const U),
+                    ptr: ptr::NonNull::new_unchecked(ptr as *mut U),
                 })
             } else {
                 None
@@ -412,7 +411,7 @@ impl<T: DomObject> LayoutDom<T> {
     /// Get the reflector.
     pub unsafe fn get_jsobject(&self) -> *mut JSObject {
         debug_assert!(thread_state::get().is_layout());
-        (*self.ptr.get()).reflector().get_jsobject().get()
+        (*self.ptr.as_ptr()).reflector().get_jsobject().get()
     }
 }
 
@@ -420,7 +419,7 @@ impl<T> Copy for LayoutDom<T> {}
 
 impl<T> PartialEq for Dom<T> {
     fn eq(&self, other: &Dom<T>) -> bool {
-        self.ptr == other.ptr
+        self.ptr.as_ptr() == other.ptr.as_ptr()
     }
 }
 
@@ -428,7 +427,7 @@ impl<T> Eq for Dom<T> {}
 
 impl<T> PartialEq for LayoutDom<T> {
     fn eq(&self, other: &LayoutDom<T>) -> bool {
-        self.ptr == other.ptr
+        self.ptr.as_ptr() == other.ptr.as_ptr()
     }
 }
 
@@ -436,13 +435,13 @@ impl<T> Eq for LayoutDom<T> {}
 
 impl<T> Hash for Dom<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.ptr.hash(state)
+        self.ptr.as_ptr().hash(state)
     }
 }
 
 impl<T> Hash for LayoutDom<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.ptr.hash(state)
+        self.ptr.as_ptr().hash(state)
     }
 }
 
@@ -474,7 +473,7 @@ impl LayoutDom<Node> {
         debug_assert!(thread_state::get().is_layout());
         let TrustedNodeAddress(addr) = inner;
         LayoutDom {
-            ptr: NonZero::new_unchecked(addr as *const Node),
+            ptr: ptr::NonNull::new_unchecked(addr as *const Node as *mut Node),
         }
     }
 }
@@ -700,7 +699,7 @@ impl<T: DomObject> LayoutDom<T> {
     /// this is unsafe is what necessitates the layout wrappers.)
     pub unsafe fn unsafe_get(&self) -> *const T {
         debug_assert!(thread_state::get().is_layout());
-        self.ptr.get()
+        self.ptr.as_ptr()
     }
 
     /// Returns a reference to the interior of this JS object. This method is
@@ -708,7 +707,7 @@ impl<T: DomObject> LayoutDom<T> {
     /// mutate DOM nodes.
     pub fn get_for_script(&self) -> &T {
         debug_assert!(thread_state::get().is_script());
-        unsafe { &*self.ptr.get() }
+        unsafe { &*self.ptr.as_ptr() }
     }
 }