Temporarially mark some unsafe code safe for the compiler plugin

gc/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

gc/src/lib.rs

@@ -52,25 +52,27 @@ impl<T: Trace> Trace for Gc<T> {
         self.inner().trace_inner();
     }
 
-    unsafe fn root(&self) {
+    fn root(&self) {
         assert!(!self.root.get(), "Can't double-root a Gc<T>");
         self.root.set(true);
-        self.inner().root_inner();
+        unsafe {
+            self.inner().root_inner();
+        }
     }
 
-    unsafe fn unroot(&self) {
+    fn unroot(&self) {
         assert!(self.root.get(), "Can't double-unroot a Gc<T>");
         self.root.set(false);
-        self.inner().unroot_inner();
+        unsafe {
+            self.inner().unroot_inner();
+        }
     }
 }
 
 impl<T: Trace> Clone for Gc<T> {
     fn clone(&self) -> Gc<T> {
-        unsafe {
-            self.root();
-            Gc { _ptr: self._ptr, root: Cell::new(true) }
-        }
+        self.root();
+        Gc { _ptr: self._ptr, root: Cell::new(true) }
     }
 }
 
@@ -91,9 +93,7 @@ impl<T: Trace> Drop for Gc<T> {
         // If we are being collected by the garbage collector (we are
         // not a root), then our reference may not be valid anymore due to cycles
         if self.root.get() {
-            unsafe {
-                self.unroot();
-            }
+            self.unroot();
         }
     }
 }
@@ -125,10 +125,8 @@ impl <T: Trace> GcCell<T> {
     pub fn borrow_mut(&self) -> GcCellRefMut<T> {
         let val_ref = self.cell.borrow_mut();
 
-        unsafe {
-            // Root everything inside the box for the lifetime of the GcCellRefMut
-            val_ref.root();
-        }
+        // Root everything inside the box for the lifetime of the GcCellRefMut
+        val_ref.root();
 
         GcCellRefMut {
             _ref: val_ref,
@@ -146,12 +144,12 @@ impl<T: Trace> Trace for GcCell<T> {
         }
     }
 
-    unsafe fn root(&self) {
+    fn root(&self) {
         // XXX: Maybe handle this better than panicking? (can we just dodge the check?)
         self.cell.borrow().root();
     }
 
-    unsafe fn unroot(&self) {
+    fn unroot(&self) {
         // XXX: Maybe handle this better than panicking? (can we just dodge the check?)
         self.cell.borrow().unroot();
     }
@@ -187,10 +185,8 @@ impl<'a, T: Trace> DerefMut for GcCellRefMut<'a, T> {
 
 impl<'a, T: Trace> Drop for GcCellRefMut<'a, T> {
     fn drop(&mut self) {
-        unsafe {
-            // The data is now within a Gc tree again
-            // we don't have to keep it alive explicitly any longer
-            self._ref.unroot();
-        }
+        // the data is now within a gc tree again
+        // we don't have to keep it alive explicitly any longer
+        self._ref.unroot();
     }
 }

gc/src/trace.rs

@@ -3,29 +3,27 @@ pub trait Trace {
     /// Mark all contained Gcs
     fn trace(&self);
     /// Increment the root-count of all contained Gcs
-    unsafe fn root(&self);
+    fn root(&self);
     /// Decrement the root-count of all contained Gcs
-    unsafe fn unroot(&self);
+    fn unroot(&self);
 }
 
-/*
-impl<'a, T> Trace for &'a T {
+impl<T> Trace for &'static T {
     fn trace(&self) {}
-    unsafe fn root(&self) {}
-    unsafe fn unroot(&self) {}
+    fn root(&self) {}
+    fn unroot(&self) {}
 }
-*/
 
 impl<'a, T: Trace> Trace for Box<T> {
     fn trace(&self) {
         (**self).trace();
     }
 
-    unsafe fn root(&self) {
+    fn root(&self) {
         (**self).root();
     }
 
-    unsafe fn unroot(&self) {
+    fn unroot(&self) {
         (**self).unroot();
     }
 }
@@ -37,13 +35,13 @@ impl<'a, T: Trace> Trace for Vec<T> {
         }
     }
 
-    unsafe fn root(&self) {
+    fn root(&self) {
         for e in self {
             e.root();
         }
     }
 
-    unsafe fn unroot(&self) {
+    fn unroot(&self) {
         for e in self {
             e.unroot();
         }