core: Convert some multiline statements to single-line

Author: brson

src/libcore/rt/context.rs

@@ -54,8 +54,7 @@ pub impl Context {
         // which we will then modify to call the given function when restored
         let mut regs = new_regs();
         unsafe {
-            swap_registers(transmute_mut_region(&mut *regs),
-                           transmute_region(&*regs))
+            swap_registers(transmute_mut_region(&mut *regs), transmute_region(&*regs))
         };
 
         initialize_call_frame(&mut *regs, fp, argp, sp);
@@ -107,8 +106,7 @@ fn new_regs() -> ~Registers {
 }
 
 #[cfg(target_arch = "x86")]
-fn initialize_call_frame(regs: &mut Registers,
-                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
 
     let sp = align_down(sp);
     let sp = mut_offset(sp, -4);
@@ -131,8 +129,7 @@ type Registers = [uint * 22];
 fn new_regs() -> ~Registers { ~[0, .. 22] }
 
 #[cfg(target_arch = "x86_64")]
-fn initialize_call_frame(regs: &mut Registers,
-                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
 
     // Redefinitions from regs.h
     const RUSTRT_ARG0: uint = 3;
@@ -166,8 +163,7 @@ type Registers = [uint * 32];
 fn new_regs() -> ~Registers { ~[0, .. 32] }
 
 #[cfg(target_arch = "arm")]
-fn initialize_call_frame(regs: &mut Registers,
-                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
     let sp = mut_offset(sp, -1);
 
     // The final return address. 0 indicates the bottom of the stack
@@ -185,8 +181,7 @@ type Registers = [uint * 32];
 fn new_regs() -> ~Registers { ~[0, .. 32] }
 
 #[cfg(target_arch = "mips")]
-fn initialize_call_frame(regs: &mut Registers,
-                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
     let sp = mut_offset(sp, -1);
 
     // The final return address. 0 indicates the bottom of the stack

src/libcore/rt/sched.rs

@@ -183,8 +183,7 @@ pub impl Scheduler {
 
         let blocked_task = self.current_task.swap_unwrap();
         let f_fake_region = unsafe {
-            transmute::<&fn(&mut Scheduler, ~Task),
-                        &fn(&mut Scheduler, ~Task)>(f)
+            transmute::<&fn(&mut Scheduler, ~Task), &fn(&mut Scheduler, ~Task)>(f)
         };
         let f_opaque = HackAroundBorrowCk::from_fn(f_fake_region);
         self.enqueue_cleanup_job(GiveTask(blocked_task, f_opaque));
@@ -233,8 +232,7 @@ pub impl Scheduler {
         Context::swap(task_context, scheduler_context);
     }
 
-    priv fn swap_in_task_from_running_task(&mut self,
-                                           running_task: &mut Task) {
+    priv fn swap_in_task_from_running_task(&mut self, running_task: &mut Task) {
         let running_task_context = &mut running_task.saved_context;
         let next_context = &self.current_task.get_ref().saved_context;
         Context::swap(running_task_context, next_context);
@@ -344,8 +342,7 @@ impl ThreadLocalScheduler {
     fn put_scheduler(&mut self, scheduler: ~Scheduler) {
         unsafe {
             let key = match self { &ThreadLocalScheduler(key) => key };
-            let value: *mut c_void =
-                transmute::<~Scheduler, *mut c_void>(scheduler);
+            let value: *mut c_void = transmute::<~Scheduler, *mut c_void>(scheduler);
             tls::set(key, value);
         }
     }
@@ -357,8 +354,9 @@ impl ThreadLocalScheduler {
             fail_unless!(value.is_not_null());
             {
                 let value_ptr = &mut value;
-                let sched: &mut ~Scheduler =
-                    transmute::<&mut *mut c_void, &mut ~Scheduler>(value_ptr);
+                let sched: &mut ~Scheduler = {
+                    transmute::<&mut *mut c_void, &mut ~Scheduler>(value_ptr)
+                };
                 let sched: &mut Scheduler = &mut **sched;
                 return sched;
             }

src/libcore/rt/uv.rs

@@ -157,10 +157,8 @@ pub impl IdleWatcher {
         };
 
         extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) {
-            let idle_watcher: IdleWatcher =
-                NativeHandle::from_native_handle(handle);
-            let cb: &IdleCallback =
-                borrow_callback_from_watcher(&idle_watcher);
+            let idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
+            let cb: &IdleCallback = borrow_callback_from_watcher(&idle_watcher);
             let status = status_to_maybe_uv_error(handle, status);
             (*cb)(idle_watcher, status);
         }
@@ -175,9 +173,7 @@ pub impl IdleWatcher {
 
         extern fn close_cb(handle: *uvll::uv_idle_t) {
             let mut idle_watcher = NativeHandle::from_native_handle(handle);
-            drop_watcher_callback::<uvll::uv_idle_t,
-                                    IdleWatcher,
-                                    IdleCallback>(&mut idle_watcher);
+            drop_watcher_callback::<uvll::uv_idle_t, IdleWatcher, IdleCallback>(&mut idle_watcher);
             unsafe { uvll::idle_delete(handle) };
         }
     }
@@ -220,21 +216,17 @@ pub impl StreamWatcher {
         let handle = self.native_handle();
         unsafe { uvll::read_start(handle, alloc_cb, read_cb); }
 
-        extern fn alloc_cb(stream: *uvll::uv_stream_t,
-                           suggested_size: size_t) -> Buf {
-            let mut stream_watcher: StreamWatcher =
-                NativeHandle::from_native_handle(stream);
+        extern fn alloc_cb(stream: *uvll::uv_stream_t, suggested_size: size_t) -> Buf {
+            let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
             let data = get_watcher_data(&mut stream_watcher);
             let alloc_cb = data.alloc_cb.get_ref();
             return (*alloc_cb)(suggested_size as uint);
         }
 
-        extern fn read_cb(stream: *uvll::uv_stream_t,
-                          nread: ssize_t, ++buf: Buf) {
+        extern fn read_cb(stream: *uvll::uv_stream_t, nread: ssize_t, ++buf: Buf) {
             rtdebug!("buf addr: %x", buf.base as uint);
             rtdebug!("buf len: %d", buf.len as int);
-            let mut stream_watcher: StreamWatcher =
-                NativeHandle::from_native_handle(stream);
+            let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
             let data = get_watcher_data(&mut stream_watcher);
             let cb = data.read_cb.get_ref();
             let status = status_to_maybe_uv_error(stream, nread as c_int);
@@ -270,14 +262,11 @@ pub impl StreamWatcher {
         let _v = vec_from_uv_buf(buf);
 
         extern fn write_cb(req: *uvll::uv_write_t, status: c_int) {
-            let write_request: WriteRequest =
-                NativeHandle::from_native_handle(req);
+            let write_request: WriteRequest = NativeHandle::from_native_handle(req);
             let mut stream_watcher = write_request.stream();
             write_request.delete();
-            let cb = get_watcher_data(&mut stream_watcher)
-                .write_cb.swap_unwrap();
-            let status = status_to_maybe_uv_error(
-                stream_watcher.native_handle(), status);
+            let cb = get_watcher_data(&mut stream_watcher).write_cb.swap_unwrap();
+            let status = status_to_maybe_uv_error(stream_watcher.native_handle(), status);
             cb(stream_watcher, status);
         }
     }
@@ -301,8 +290,7 @@ pub impl StreamWatcher {
         unsafe { uvll::close(self.native_handle(), close_cb); }
 
         extern fn close_cb(handle: *uvll::uv_stream_t) {
-            let mut stream_watcher: StreamWatcher =
-                NativeHandle::from_native_handle(handle);
+            let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
             {
                 let mut data = get_watcher_data(&mut stream_watcher);
                 data.close_cb.swap_unwrap()();
@@ -382,16 +370,14 @@ pub impl TcpWatcher {
 
             extern fn connect_cb(req: *uvll::uv_connect_t, status: c_int) {
                 rtdebug!("connect_t: %x", req as uint);
-                let connect_request: ConnectRequest =
-                    NativeHandle::from_native_handle(req);
+                let connect_request: ConnectRequest = NativeHandle::from_native_handle(req);
                 let mut stream_watcher = connect_request.stream();
                 connect_request.delete();
                 let cb: ConnectionCallback = {
                     let data = get_watcher_data(&mut stream_watcher);
                     data.connect_cb.swap_unwrap()
                 };
-                let status = status_to_maybe_uv_error(
-                    stream_watcher.native_handle(), status);
+                let status = status_to_maybe_uv_error(stream_watcher.native_handle(), status);
                 cb(stream_watcher, status);
             }
         }
@@ -412,19 +398,15 @@ pub impl TcpWatcher {
 
         extern fn connection_cb(handle: *uvll::uv_stream_t, status: c_int) {
             rtdebug!("connection_cb");
-            let mut stream_watcher: StreamWatcher =
-                NativeHandle::from_native_handle(handle);
-            let cb = get_watcher_data(&mut stream_watcher)
-                .connect_cb.swap_unwrap();
-            let status = status_to_maybe_uv_error(
-                stream_watcher.native_handle(), status);
+            let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
+            let cb = get_watcher_data(&mut stream_watcher).connect_cb.swap_unwrap();
+            let status = status_to_maybe_uv_error(stream_watcher.native_handle(), status);
             cb(stream_watcher, status);
         }
     }
 
     fn as_stream(&self) -> StreamWatcher {
-        NativeHandle::from_native_handle(
-            self.native_handle() as *uvll::uv_stream_t)
+        NativeHandle::from_native_handle(self.native_handle() as *uvll::uv_stream_t)
     }
 }
 
@@ -460,9 +442,7 @@ impl ConnectRequest {
 
     fn stream(&self) -> StreamWatcher {
         unsafe {
-            let stream_handle =
-                uvll::get_stream_handle_from_connect_req(
-                    self.native_handle());
+            let stream_handle = uvll::get_stream_handle_from_connect_req(self.native_handle());
             NativeHandle::from_native_handle(stream_handle)
         }
     }
@@ -499,8 +479,7 @@ impl WriteRequest {
 
     fn stream(&self) -> StreamWatcher {
         unsafe {
-            let stream_handle =
-                uvll::get_stream_handle_from_write_req(self.native_handle());
+            let stream_handle = uvll::get_stream_handle_from_write_req(self.native_handle());
             NativeHandle::from_native_handle(stream_handle)
         }
     }
@@ -609,8 +588,7 @@ fn drop_watcher_callback<H, W: Watcher + NativeHandle<*H>, CB: Callback>(
             // Take ownership of the callback and drop it
             let _cb = transmute::<*c_void, ~CB>(handle_data);
             // Make sure the pointer is zeroed
-            uvll::set_data_for_uv_handle(
-                watcher.native_handle(), null::<()>());
+            uvll::set_data_for_uv_handle(watcher.native_handle(), null::<()>());
         }
     }
 }

src/libcore/rt/uvio.rs

@@ -189,12 +189,9 @@ impl TcpListener for UvTcpListener {
                 do server_tcp_watcher.listen |server_stream_watcher, status| {
                     let maybe_stream = if status.is_none() {
                         let mut server_stream_watcher = server_stream_watcher;
-                        let mut loop_ =
-                            loop_from_watcher(&server_stream_watcher);
-                        let mut client_tcp_watcher =
-                            TcpWatcher::new(&mut loop_);
-                        let mut client_tcp_watcher =
-                            client_tcp_watcher.as_stream();
+                        let mut loop_ = loop_from_watcher(&server_stream_watcher);
+                        let mut client_tcp_watcher = TcpWatcher::new(&mut loop_);
+                        let mut client_tcp_watcher = client_tcp_watcher.as_stream();
                         // XXX: Need's to be surfaced in interface
                         server_stream_watcher.accept(client_tcp_watcher);
                         Some(~UvStream::new(client_tcp_watcher))
@@ -425,8 +422,7 @@ fn test_read_and_block() {
                         // Yield to the other task in hopes that it
                         // will trigger a read callback while we are
                         // not ready for it
-                        do scheduler.block_running_task_and_then
-                            |scheduler, task| {
+                        do scheduler.block_running_task_and_then |scheduler, task| {
                             scheduler.task_queue.push_back(task);
                         }
                     }