---

yaml
---
r: 37562
b: refs/heads/try
c: c44c9a4
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: 11024eaebbd5d958df3944178e5746c0d9fda383
+refs/heads/try: c44c9a47d828e93344a9af659c3245bb2502630a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/libstd/arc.rs

@@ -217,10 +217,7 @@ fn check_poison(is_mutex: bool, failed: bool) {
 #[doc(hidden)]
 struct PoisonOnFail {
     failed: &mut bool,
-}
-
-impl PoisonOnFail : Drop {
-    fn finalize() {
+    drop {
         /* assert !*self.failed; -- might be false in case of cond.wait() */
         if task::failing() { *self.failed = true; }
     }

branches/try/src/libstd/arena.rs

@@ -55,10 +55,7 @@ pub struct Arena {
     priv mut head: Chunk,
     priv mut pod_head: Chunk,
     priv mut chunks: @List<Chunk>,
-}
-
-impl Arena : Drop {
-    fn finalize() {
+    drop {
         unsafe {
             destroy_chunk(&self.head);
             for list::each(self.chunks) |chunk| {

branches/try/src/libstd/c_vec.rs

@@ -39,15 +39,12 @@ pub enum CVec<T> {
 
 struct DtorRes {
   dtor: Option<fn@()>,
-}
-
-impl DtorRes : Drop {
-    fn finalize() {
+  drop {
     match self.dtor {
       option::None => (),
       option::Some(f) => f()
     }
-    }
+  }
 }
 
 fn DtorRes(dtor: Option<fn@()>) -> DtorRes {

branches/try/src/libstd/future.rs

@@ -23,12 +23,10 @@ use cast::copy_lifetime;
 #[doc = "The future type"]
 pub struct Future<A> {
     /*priv*/ mut state: FutureState<A>,
-}
 
-// FIXME(#2829) -- futures should not be copyable, because they close
-// over fn~'s that have pipes and so forth within!
-impl<A> Future<A> : Drop {
-    fn finalize() {}
+    // FIXME(#2829) -- futures should not be copyable, because they close
+    // over fn~'s that have pipes and so forth within!
+    drop {}
 }
 
 priv enum FutureState<A> {

branches/try/src/libstd/net_tcp.rs

@@ -27,14 +27,11 @@ extern mod rustrt {
  */
 struct TcpSocket {
   socket_data: @TcpSocketData,
-}
-
-impl TcpSocket : Drop {
-    fn finalize() {
+  drop {
     unsafe {
         tear_down_socket_data(self.socket_data)
     }
-    }
+  }
 }
 
 pub fn TcpSocket(socket_data: @TcpSocketData) -> TcpSocket {

branches/try/src/libstd/sort.rs

@@ -1133,10 +1133,7 @@ mod big_tests {
         val: uint,
         key: fn(@uint),
 
-    }
-
-    impl LVal : Drop {
-        fn finalize() {
+        drop {
             let x = unsafe { task::local_data::local_data_get(self.key) };
             match x {
                 Some(@y) => {

branches/try/src/libstd/sync.rs

@@ -150,12 +150,7 @@ impl &Sem<~[mut Waitqueue]> {
 #[doc(hidden)]
 struct SemRelease {
     sem: &Sem<()>,
-}
-
-impl SemRelease : Drop {
-    fn finalize() {
-        self.sem.release();
-    }
+    drop { self.sem.release(); }
 }
 
 fn SemRelease(sem: &r/Sem<()>) -> SemRelease/&r {
@@ -167,12 +162,7 @@ fn SemRelease(sem: &r/Sem<()>) -> SemRelease/&r {
 #[doc(hidden)]
 struct SemAndSignalRelease {
     sem: &Sem<~[mut Waitqueue]>,
-}
-
-impl SemAndSignalRelease : Drop {
-    fn finalize() {
-        self.sem.release();
-    }
+    drop { self.sem.release(); }
 }
 
 fn SemAndSignalRelease(sem: &r/Sem<~[mut Waitqueue]>)
@@ -183,9 +173,7 @@ fn SemAndSignalRelease(sem: &r/Sem<~[mut Waitqueue]>)
 }
 
 /// A mechanism for atomic-unlock-and-deschedule blocking and signalling.
-pub struct Condvar { priv sem: &Sem<~[mut Waitqueue]> }
-
-impl Condvar : Drop { fn finalize() {} }
+pub struct Condvar { priv sem: &Sem<~[mut Waitqueue]>, drop { } }
 
 impl &Condvar {
     /**
@@ -254,15 +242,10 @@ impl &Condvar {
         // bounded in when it gets released, this shouldn't hang forever.
         struct SemAndSignalReacquire {
             sem: &Sem<~[mut Waitqueue]>,
-        }
-
-        impl SemAndSignalReacquire : Drop {
-            fn finalize() {
-                unsafe {
-                    // Needs to succeed, instead of itself dying.
-                    do task::unkillable {
-                        self.sem.acquire();
-                    }
+            drop unsafe {
+                // Needs to succeed, instead of itself dying.
+                do task::unkillable {
+                    self.sem.acquire();
                 }
             }
         }
@@ -598,26 +581,21 @@ impl &RWlock {
 #[doc(hidden)]
 struct RWlockReleaseRead {
     lock: &RWlock,
-}
-
-impl RWlockReleaseRead : Drop {
-    fn finalize() {
-        unsafe {
-            do task::unkillable {
-                let mut last_reader = false;
-                do self.lock.state.with |state| {
-                    assert state.read_mode;
-                    assert state.read_count > 0;
-                    state.read_count -= 1;
-                    if state.read_count == 0 {
-                        last_reader = true;
-                        state.read_mode = false;
-                    }
-                }
-                if last_reader {
-                    (&self.lock.access_lock).release();
+    drop unsafe {
+        do task::unkillable {
+            let mut last_reader = false;
+            do self.lock.state.with |state| {
+                assert state.read_mode;
+                assert state.read_count > 0;
+                state.read_count -= 1;
+                if state.read_count == 0 {
+                    last_reader = true;
+                    state.read_mode = false;
                 }
             }
+            if last_reader {
+                (&self.lock.access_lock).release();
+            }
         }
     }
 }
@@ -632,34 +610,28 @@ fn RWlockReleaseRead(lock: &r/RWlock) -> RWlockReleaseRead/&r {
 #[doc(hidden)]
 struct RWlockReleaseDowngrade {
     lock: &RWlock,
-}
-
-impl RWlockReleaseDowngrade : Drop {
-    fn finalize() {
-        unsafe {
-            do task::unkillable {
-                let mut writer_or_last_reader = false;
-                do self.lock.state.with |state| {
-                    if state.read_mode {
-                        assert state.read_count > 0;
-                        state.read_count -= 1;
-                        if state.read_count == 0 {
-                            // Case 1: Writer downgraded & was the last reader
-                            writer_or_last_reader = true;
-                            state.read_mode = false;
-                        } else {
-                            // Case 2: Writer downgraded & was not the last
-                            // reader
-                        }
-                    } else {
-                        // Case 3: Writer did not downgrade
+    drop unsafe {
+        do task::unkillable {
+            let mut writer_or_last_reader = false;
+            do self.lock.state.with |state| {
+                if state.read_mode {
+                    assert state.read_count > 0;
+                    state.read_count -= 1;
+                    if state.read_count == 0 {
+                        // Case 1: Writer downgraded & was the last reader
                         writer_or_last_reader = true;
+                        state.read_mode = false;
+                    } else {
+                        // Case 2: Writer downgraded & was not the last reader
                     }
-                }
-                if writer_or_last_reader {
-                    (&self.lock.access_lock).release();
+                } else {
+                    // Case 3: Writer did not downgrade
+                    writer_or_last_reader = true;
                 }
             }
+            if writer_or_last_reader {
+                (&self.lock.access_lock).release();
+            }
         }
     }
 }
@@ -671,11 +643,9 @@ fn RWlockReleaseDowngrade(lock: &r/RWlock) -> RWlockReleaseDowngrade/&r {
 }
 
 /// The "write permission" token used for rwlock.write_downgrade().
-pub struct RWlockWriteMode { /* priv */ lock: &RWlock }
-impl RWlockWriteMode : Drop { fn finalize() {} }
+pub struct RWlockWriteMode { /* priv */ lock: &RWlock, drop { } }
 /// The "read permission" token used for rwlock.write_downgrade().
-pub struct RWlockReadMode  { priv lock: &RWlock }
-impl RWlockReadMode : Drop { fn finalize() {} }
+pub struct RWlockReadMode  { priv lock: &RWlock, drop { } }
 
 impl &RWlockWriteMode {
     /// Access the pre-downgrade rwlock in write mode.
@@ -984,12 +954,7 @@ mod tests {
         }
         struct SendOnFailure {
             c: pipes::Chan<()>,
-        }
-
-        impl SendOnFailure : Drop {
-            fn finalize() {
-                self.c.send(());
-            }
+            drop { self.c.send(()); }
         }
 
         fn SendOnFailure(c: pipes::Chan<()>) -> SendOnFailure {

branches/try/src/libstd/thread_pool.rs

@@ -13,10 +13,7 @@ pub struct ThreadPool<T> {
     channels: ~[Chan<Msg<T>>],
     mut next_index: uint,
 
-}
-
-impl<T> ThreadPool<T> {
-    fn finalize() {
+    drop {
         for self.channels.each |channel| {
             channel.send(Quit);
         }