Make Send and Sync traits unsafe

Author: flaper87

src/liballoc/arc.rs

@@ -129,9 +129,9 @@ pub struct Weak<T> {
     _ptr: *mut ArcInner<T>,
 }
 
-impl<T: Sync + Send> Send for Arc<T> { }
+unsafe impl<T: Sync + Send> Send for Arc<T> { }
 
-impl<T: Sync + Send> Sync for Arc<T> { }
+unsafe impl<T: Sync + Send> Sync for Arc<T> { }
 
 struct ArcInner<T> {
     strong: atomic::AtomicUint,

src/libcore/cell.rs

@@ -577,6 +577,6 @@ impl<T> RacyCell<T> {
     }
 }
 
-impl<T:Send> Send for RacyCell<T> { }
+unsafe impl<T:Send> Send for RacyCell<T> { }
 
-impl<T> Sync for RacyCell<T> { } // Oh dear
+unsafe impl<T> Sync for RacyCell<T> { } // Oh dear

src/libcore/kinds.rs

@@ -19,7 +19,7 @@
 
 /// Types able to be transferred across task boundaries.
 #[lang="send"]
-pub trait Send for Sized? : 'static {
+pub unsafe trait Send for Sized? : 'static {
     // empty.
 }
 
@@ -81,7 +81,7 @@ pub trait Copy for Sized? {
 /// reference; not doing this is undefined behaviour (for example,
 /// `transmute`-ing from `&T` to `&mut T` is illegal).
 #[lang="sync"]
-pub trait Sync for Sized? {
+pub unsafe trait Sync for Sized? {
     // Empty
 }
 

src/libcore/ptr.rs

@@ -515,13 +515,13 @@ pub struct UniquePtr<T>(pub *mut T);
 /// reference is unaliased. Note that this aliasing invariant is
 /// unenforced by the type system; the abstraction using the
 /// `UniquePtr` must enforce it.
-impl<T:Send> Send for UniquePtr<T> { }
+unsafe impl<T:Send> Send for UniquePtr<T> { }
 
 /// `UniquePtr` pointers are `Sync` if `T` is `Sync` because the data they
 /// reference is unaliased. Note that this aliasing invariant is
 /// unenforced by the type system; the abstraction using the
 /// `UniquePtr` must enforce it.
-impl<T:Sync> Sync for UniquePtr<T> { }
+unsafe impl<T:Sync> Sync for UniquePtr<T> { }
 
 impl<T> UniquePtr<T> {
     /// Returns a null UniquePtr.

src/librustc_trans/back/write.rs

@@ -281,7 +281,7 @@ struct ModuleConfig {
     time_passes: bool,
 }
 
-impl Send for ModuleConfig { }
+unsafe impl Send for ModuleConfig { }
 
 impl ModuleConfig {
     fn new(tm: TargetMachineRef, passes: Vec<String>) -> ModuleConfig {

src/librustc_trans/trans/mod.rs

@@ -60,8 +60,8 @@ pub struct ModuleTranslation {
     pub llmod: ModuleRef,
 }
 
-impl Send for ModuleTranslation { }
-impl Sync for ModuleTranslation { }
+unsafe impl Send for ModuleTranslation { }
+unsafe impl Sync for ModuleTranslation { }
 
 pub struct CrateTranslation {
     pub modules: Vec<ModuleTranslation>,

src/libstd/c_str.rs

@@ -89,8 +89,8 @@ pub struct CString {
     owns_buffer_: bool,
 }
 
-impl Send for CString { }
-impl Sync for CString { }
+unsafe impl Send for CString { }
+unsafe impl Sync for CString { }
 
 impl Clone for CString {
     /// Clone this CString into a new, uniquely owned CString. For safety

src/libstd/comm/blocking.rs

@@ -13,16 +13,19 @@
 use thread::Thread;
 use sync::atomic::{AtomicBool, INIT_ATOMIC_BOOL, Ordering};
 use sync::Arc;
+use kinds::{Sync, Send};
 use kinds::marker::{NoSend, NoSync};
 use mem;
 use clone::Clone;
 
-#[deriving(Send, Sync)]
 struct Inner {
     thread: Thread,
     woken: AtomicBool,
 }
 
+unsafe impl Send for Inner {}
+unsafe impl Sync for Inner {}
+
 #[deriving(Clone)]
 pub struct SignalToken {
     inner: Arc<Inner>,

src/libstd/comm/mod.rs

@@ -363,7 +363,7 @@ pub struct Receiver<T> {
 
 // The receiver port can be sent from place to place, so long as it
 // is not used to receive non-sendable things.
-impl<T:Send> Send for Receiver<T> { }
+unsafe impl<T:Send> Send for Receiver<T> { }
 
 /// An iterator over messages on a receiver, this iterator will block
 /// whenever `next` is called, waiting for a new message, and `None` will be
@@ -382,7 +382,7 @@ pub struct Sender<T> {
 
 // The send port can be sent from place to place, so long as it
 // is not used to send non-sendable things.
-impl<T:Send> Send for Sender<T> { }
+unsafe impl<T:Send> Send for Sender<T> { }
 
 /// The sending-half of Rust's synchronous channel type. This half can only be
 /// owned by one task, but it can be cloned to send to other tasks.

src/libstd/comm/mpsc_queue.rs

@@ -76,8 +76,8 @@ pub struct Queue<T> {
     tail: UnsafeCell<*mut Node<T>>,
 }
 
-impl<T:Send> Send for Queue<T> { }
-impl<T:Send> Sync for Queue<T> { }
+unsafe impl<T:Send> Send for Queue<T> { }
+unsafe impl<T:Send> Sync for Queue<T> { }
 
 impl<T> Node<T> {
     unsafe fn new(v: Option<T>) -> *mut Node<T> {