Mark exclusive arc-related functions as unsafe. Fixes #2727.

src/libcore/arc.rs

@@ -104,19 +104,17 @@ impl methods<T: send> for exclusive<T> {
         arc_destruct(self.data)
     }
 
-    fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
+    unsafe fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
-        unsafe {
+        let ptr: ~arc_data<ex_data<T>> =
-            let ptr: ~arc_data<ex_data<T>> =
+            unsafe::reinterpret_cast(self.data);
-                  unsafe::reinterpret_cast(self.data);
+        let r = {
-            let r = {
+            let rec: &ex_data<T> = &(*ptr).data;
-                let rec: &ex_data<T> = &(*ptr).data;
+            rec.lock.lock_cond() {|c|
-                rec.lock.lock_cond() {|c|
+                f(c, &rec.data)
-                    f(c, &rec.data)
+            }
-                }
+        };
-            };
+        unsafe::forget(ptr);
-            unsafe::forget(ptr);
+        r
-            r
-        }
     }
 }
 

src/libcore/sys.rs

@@ -106,13 +106,13 @@ fn create_lock() -> lock_and_signal {
 }
 
 impl methods for lock_and_signal {
-    fn lock<T>(f: fn() -> T) -> T {
+    unsafe fn lock<T>(f: fn() -> T) -> T {
         rustrt::rust_lock_cond_lock(self.lock);
         let _r = unlock(self.lock);
         f()
     }
 
-    fn lock_cond<T>(f: fn(condition) -> T) -> T {
+    unsafe fn lock_cond<T>(f: fn(condition) -> T) -> T {
         rustrt::rust_lock_cond_lock(self.lock);
         let _r = unlock(self.lock);
         f(condition_(self.lock))