---

yaml
---
r: 63246
b: refs/heads/snap-stage3
c: e7213aa
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 84280819585fb65bf18903aef9364579f3552522
+refs/heads/snap-stage3: e7213aa21e9a79db01d2e9d1b76761a420e4c967
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/macros.rs

@@ -38,29 +38,16 @@ macro_rules! rtassert (
     } )
 )
 
-
-// The do_abort function was originally inside the abort macro, but
-// this was ICEing the compiler so it has been moved outside. Now this
-// seems to work?
-pub fn do_abort() -> ! {
-    unsafe { ::libc::abort(); }
-}
-
 macro_rules! abort(
     ($( $msg:expr),+) => ( {
         rtdebug!($($msg),+);
 
-//        do_abort();
-
-        // NB: This is in a fn to avoid putting the `unsafe` block in
-        // a macro, which causes spurious 'unnecessary unsafe block'
-        // warnings.
-//        fn do_abort() -> ! {
-//            unsafe { ::libc::abort(); }
-//        }
-
-        ::macros::do_abort();
+        do_abort();
 
+        // NB: This is in a fn to avoid putting the `unsafe` block in a macro,
+        // which causes spurious 'unnecessary unsafe block' warnings.
+        fn do_abort() -> ! {
+            unsafe { ::libc::abort(); }
+        }
     } )
 )
-

branches/snap-stage3/src/libstd/rt/comm.rs

@@ -120,13 +120,13 @@ impl<T> ChanOne<T> {
             match oldstate {
                 STATE_BOTH => {
                     // Port is not waiting yet. Nothing to do
-                    do Local::borrow::<Scheduler, ()> |sched| {
+                    do Local::borrow::<Scheduler> |sched| {
                         rtdebug!("non-rendezvous send");
                         sched.metrics.non_rendezvous_sends += 1;
                     }
                 }
                 STATE_ONE => {
-                    do Local::borrow::<Scheduler, ()> |sched| {
+                    do Local::borrow::<Scheduler> |sched| {
                         rtdebug!("rendezvous send");
                         sched.metrics.rendezvous_sends += 1;
                     }

branches/snap-stage3/src/libstd/rt/io/extensions.rs

@@ -749,8 +749,6 @@ mod test {
     #[should_fail]
     #[ignore(cfg(windows))]
     fn push_bytes_fail_reset_len() {
-        use unstable::finally::Finally;
-
         // push_bytes unsafely sets the vector length. This is testing that
         // upon failure the length is reset correctly.
         let mut reader = MockReader::new();
@@ -772,7 +770,8 @@ mod test {
             reader.push_bytes(&mut *buf, 4);
         }).finally {
             // NB: Using rtassert here to trigger abort on failure since this is a should_fail test
-            rtassert!(*buf == ~[8, 9, 10]);
+            // FIXME: #7049 This fails because buf is still borrowed
+            //rtassert!(*buf == ~[8, 9, 10]);
         }
     }
 

branches/snap-stage3/src/libstd/rt/local.rs

@@ -18,7 +18,7 @@ pub trait Local {
     fn put(value: ~Self);
     fn take() -> ~Self;
     fn exists() -> bool;
-    fn borrow<T>(f: &fn(&mut Self) -> T) -> T;
+    fn borrow(f: &fn(&mut Self));
     unsafe fn unsafe_borrow() -> *mut Self;
     unsafe fn try_unsafe_borrow() -> Option<*mut Self>;
 }
@@ -27,20 +27,7 @@ impl Local for Scheduler {
     fn put(value: ~Scheduler) { unsafe { local_ptr::put(value) }}
     fn take() -> ~Scheduler { unsafe { local_ptr::take() } }
     fn exists() -> bool { local_ptr::exists() }
-    fn borrow<T>(f: &fn(&mut Scheduler) -> T) -> T {
-        let mut res: Option<T> = None;
-        let res_ptr: *mut Option<T> = &mut res;
-        unsafe { 
-            do local_ptr::borrow |sched| {
-                let result = f(sched);
-                *res_ptr = Some(result);
-            }
-        }
-        match res {
-            Some(r) => { r }
-            None => abort!("function failed!")
-        }               
-    }
+    fn borrow(f: &fn(&mut Scheduler)) { unsafe { local_ptr::borrow(f) } }
     unsafe fn unsafe_borrow() -> *mut Scheduler { local_ptr::unsafe_borrow() }
     unsafe fn try_unsafe_borrow() -> Option<*mut Scheduler> { abort!("unimpl") }
 }
@@ -49,8 +36,8 @@ impl Local for Task {
     fn put(_value: ~Task) { abort!("unimpl") }
     fn take() -> ~Task { abort!("unimpl") }
     fn exists() -> bool { abort!("unimpl") }
-    fn borrow<T>(f: &fn(&mut Task) -> T) -> T {
-        do Local::borrow::<Scheduler, T> |sched| {
+    fn borrow(f: &fn(&mut Task)) {
+        do Local::borrow::<Scheduler> |sched| {
             match sched.current_task {
                 Some(~ref mut task) => {
                     f(&mut *task.task)
@@ -87,7 +74,7 @@ impl Local for IoFactoryObject {
     fn put(_value: ~IoFactoryObject) { abort!("unimpl") }
     fn take() -> ~IoFactoryObject { abort!("unimpl") }
     fn exists() -> bool { abort!("unimpl") }
-    fn borrow<T>(_f: &fn(&mut IoFactoryObject) -> T) -> T { abort!("unimpl") }
+    fn borrow(_f: &fn(&mut IoFactoryObject)) { abort!("unimpl") }
     unsafe fn unsafe_borrow() -> *mut IoFactoryObject {
         let sched = Local::unsafe_borrow::<Scheduler>();
         let io: *mut IoFactoryObject = (*sched).event_loop.io().unwrap();
@@ -128,16 +115,4 @@ mod test {
         }
         let _scheduler: ~Scheduler = Local::take();
     }
-
-    #[test]
-    fn borrow_with_return() {
-        let scheduler = ~new_test_uv_sched();
-        Local::put(scheduler);
-        let res = do Local::borrow::<Scheduler,bool> |_sched| {
-            true
-        };
-        assert!(res)
-        let _scheduler: ~Scheduler = Local::take();
-    }
-            
 }

branches/snap-stage3/src/libstd/rt/mod.rs

@@ -208,7 +208,7 @@ pub fn context() -> RuntimeContext {
     } else {
         if Local::exists::<Scheduler>() {
             let context = ::cell::empty_cell();
-            do Local::borrow::<Scheduler, ()> |sched| {
+            do Local::borrow::<Scheduler> |sched| {
                 if sched.in_task_context() {
                     context.put_back(TaskContext);
                 } else {