Make cx always the first argument

Author: cramertj

futures-channel/src/mpsc/mod.rs

@@ -407,7 +407,7 @@ impl<T> Sender<T> {
         }
 
         // The channel has capacity to accept the message, so send it
-        self.do_send(Some(msg), None)
+        self.do_send(None, Some(msg))
             .map_err(|ChannelClosed(v)| {
                 TryChannelClosed {
                     kind: TryChannelClosedKind::Disconnected(v.unwrap()),
@@ -419,12 +419,12 @@ impl<T> Sender<T> {
     /// This function should only be called after `poll_ready` has responded
     /// that the channel is ready to receive a message.
     pub fn start_send(&mut self, msg: T) -> Result<(), ChannelClosed<T>> {
-        self.do_send(Some(msg), None)
+        self.do_send(None, Some(msg))
     }
 
     // Do the send without failing
     // None means close
-    fn do_send(&mut self, msg: Option<T>, cx: Option<&mut task::Context>)
+    fn do_send(&mut self, cx: Option<&mut task::Context>, msg: Option<T>)
         -> Result<(), ChannelClosed<T>>
     {
         // First, increment the number of messages contained by the channel.

futures-io/src/lib.rs

@@ -97,7 +97,7 @@ if_std! {
         /// If reading would block, this function returns `Ok(Async::Pending)`
         /// and arranges for `cx.waker()` to receive a notification when the
         /// object becomes readable or is closed.
-        fn poll_read(&mut self, buf: &mut [u8], cx: &mut task::Context)
+        fn poll_read(&mut self, cx: &mut task::Context, buf: &mut [u8])
             -> Poll<usize, Error>;
 
         /// Attempt to read from the `AsyncRead` into `vec` using vectored
@@ -113,11 +113,11 @@ if_std! {
         /// If reading would block, this function returns `Ok(Async::Pending)`
         /// and arranges for `cx.waker()` to receive a notification when the
         /// object becomes readable or is closed.
-        fn poll_vectored_read(&mut self, vec: &mut [&mut IoVec], cx: &mut task::Context)
+        fn poll_vectored_read(&mut self, cx: &mut task::Context, vec: &mut [&mut IoVec])
             -> Poll<usize, Error>
         {
-            if let Some(first_iovec) = vec.get_mut(0) {
-                self.poll_read(&mut *first_iovec, cx)
+            if let Some(ref mut first_iovec) = vec.get_mut(0) {
+                self.poll_read(cx, first_iovec)
             } else {
                 // `vec` is empty.
                 return Ok(Async::Ready(0));
@@ -134,7 +134,7 @@ if_std! {
         /// If writing would block, this function returns `Ok(Async::Pending)`
         /// and arranges for `cx.waker()` to receive a notification when the
         /// the object becomes writable or is closed.
-        fn poll_write(&mut self, buf: &[u8], cx: &mut task::Context)
+        fn poll_write(&mut self, cx: &mut task::Context, buf: &[u8])
             -> Poll<usize, Error>;
 
         /// Attempt to write bytes from `vec` into the object using vectored
@@ -150,11 +150,11 @@ if_std! {
         /// If writing would block, this function returns `Ok(Async::Pending)`
         /// and arranges for `cx.waker()` to receive a notification when the
         /// object becomes writable or is closed.
-        fn poll_vectored_write(&mut self, vec: &[&IoVec], cx: &mut task::Context)
+        fn poll_vectored_write(&mut self, cx: &mut task::Context, vec: &[&IoVec])
             -> Poll<usize, Error>
         {
-            if let Some(first_iovec) = vec.get(0) {
-                self.poll_write(&*first_iovec, cx)
+            if let Some(ref first_iovec) = vec.get(0) {
+                self.poll_write(cx, &*first_iovec)
             } else {
                 // `vec` is empty.
                 return Ok(Async::Ready(0));
@@ -187,16 +187,16 @@ if_std! {
                 (**self).initializer()
             }
 
-            fn poll_read(&mut self, buf: &mut [u8], cx: &mut task::Context)
+            fn poll_read(&mut self, cx: &mut task::Context, buf: &mut [u8])
                 -> Poll<usize, Error>
             {
-                (**self).poll_read(buf, cx)
+                (**self).poll_read(cx, buf)
             }
 
-            fn poll_vectored_read(&mut self, vec: &mut [&mut IoVec], cx: &mut task::Context)
+            fn poll_vectored_read(&mut self, cx: &mut task::Context, vec: &mut [&mut IoVec])
                 -> Poll<usize, Error>
             {
-                (**self).poll_vectored_read(vec, cx)
+                (**self).poll_vectored_read(cx, vec)
             }
         }
     }
@@ -217,7 +217,7 @@ if_std! {
                 Initializer::nop()
             }
 
-            fn poll_read(&mut self, buf: &mut [u8], _: &mut task::Context)
+            fn poll_read(&mut self, _: &mut task::Context, buf: &mut [u8])
                 -> Poll<usize, Error>
             {
                 Ok(Async::Ready(StdIo::Read::read(self, buf)?))
@@ -239,16 +239,16 @@ if_std! {
 
     macro_rules! deref_async_write {
         () => {
-            fn poll_write(&mut self, buf: &[u8], cx: &mut task::Context)
+            fn poll_write(&mut self, cx: &mut task::Context, buf: &[u8])
                 -> Poll<usize, Error>
             {
-                (**self).poll_write(buf, cx)
+                (**self).poll_write(cx, buf)
             }
 
-            fn poll_vectored_write(&mut self, vec: &[&IoVec], cx: &mut task::Context)
+            fn poll_vectored_write(&mut self, cx: &mut task::Context, vec: &[&IoVec])
                 -> Poll<usize, Error>
             {
-                (**self).poll_vectored_write(vec, cx)
+                (**self).poll_vectored_write(cx, vec)
             }
 
             fn poll_flush(&mut self, cx: &mut task::Context) -> Poll<(), Error> {
@@ -271,7 +271,7 @@ if_std! {
 
     macro_rules! delegate_async_write_to_stdio {
         () => {
-            fn poll_write(&mut self, buf: &[u8], _: &mut task::Context)
+            fn poll_write(&mut self, _: &mut task::Context, buf: &[u8])
                 -> Poll<usize, Error>
             {
                 Ok(Async::Ready(StdIo::Write::write(self, buf)?))

futures-util/src/io/allow_std.rs

@@ -55,7 +55,7 @@ impl<T> io::Write for AllowStdIo<T> where T: io::Write {
 }
 
 impl<T> AsyncWrite for AllowStdIo<T> where T: io::Write {
-    fn poll_write(&mut self, buf: &[u8], _: &mut task::Context)
+    fn poll_write(&mut self, _: &mut task::Context, buf: &[u8])
         -> Poll<usize, io::Error>
     {
         Ok(Async::Ready(io::Write::write(&mut self.0, buf)?))
@@ -88,7 +88,7 @@ impl<T> io::Read for AllowStdIo<T> where T: io::Read {
 }
 
 impl<T> AsyncRead for AllowStdIo<T> where T: io::Read {
-    fn poll_read(&mut self, buf: &mut [u8], _: &mut task::Context)
+    fn poll_read(&mut self, _: &mut task::Context, buf: &mut [u8])
         -> Poll<usize, io::Error>
     {
         Ok(Async::Ready(io::Read::read(&mut self.0, buf)?))

futures-util/src/io/copy.rs

@@ -61,7 +61,7 @@ impl<R, W> Future for Copy<R, W>
             // continue.
             if self.pos == self.cap && !self.read_done {
                 let reader = self.reader.as_mut().unwrap();
-                let n = try_ready!(reader.poll_read(&mut self.buf, cx));
+                let n = try_ready!(reader.poll_read(cx, &mut self.buf));
                 if n == 0 {
                     self.read_done = true;
                 } else {
@@ -73,7 +73,7 @@ impl<R, W> Future for Copy<R, W>
             // If our buffer has some data, let's write it out!
             while self.pos < self.cap {
                 let writer = self.writer.as_mut().unwrap();
-                let i = try_ready!(writer.poll_write(&self.buf[self.pos..self.cap], cx));
+                let i = try_ready!(writer.poll_write(cx, &self.buf[self.pos..self.cap]));
                 if i == 0 {
                     return Err(io::Error::new(io::ErrorKind::WriteZero,
                                               "write zero byte into writer"));

futures-util/src/io/framed.rs

@@ -175,16 +175,16 @@ impl<T: AsyncRead, U> AsyncRead for Fuse<T, U> {
         self.0.initializer()
     }
 
-    fn poll_read(&mut self, buf: &mut [u8], cx: &mut task::Context)
+    fn poll_read(&mut self, cx: &mut task::Context, buf: &mut [u8])
         -> Poll<usize, io::Error>
     {
-        self.0.poll_read(buf, cx)
+        self.0.poll_read(cx, buf)
     }
 
-    fn poll_vectored_read(&mut self, vec: &mut [&mut IoVec], cx: &mut task::Context)
+    fn poll_vectored_read(&mut self, cx: &mut task::Context, vec: &mut [&mut IoVec])
         -> Poll<usize, io::Error>
     {
-        self.0.poll_vectored_read(vec, cx)
+        self.0.poll_vectored_read(cx, vec)
     }
 }
 
@@ -199,16 +199,16 @@ impl<T: Write, U> Write for Fuse<T, U> {
 }
 
 impl<T: AsyncWrite, U> AsyncWrite for Fuse<T, U> {
-    fn poll_write(&mut self, buf: &[u8], cx: &mut task::Context)
+    fn poll_write(&mut self, cx: &mut task::Context, buf: &[u8])
         -> Poll<usize, io::Error>
     {
-        self.0.poll_write(buf, cx)
+        self.0.poll_write(cx, buf)
     }
 
-    fn poll_vectored_write(&mut self, vec: &[&IoVec], cx: &mut task::Context)
+    fn poll_vectored_write(&mut self, cx: &mut task::Context, vec: &[&IoVec])
         -> Poll<usize, io::Error>
     {
-        self.0.poll_vectored_write(vec, cx)
+        self.0.poll_vectored_write(cx, vec)
     }
 
     fn poll_flush(&mut self, cx: &mut task::Context) -> Poll<(), io::Error> {

futures-util/src/io/framed_read.rs

@@ -287,7 +287,7 @@ impl<T> Stream for FramedRead2<T>
             // got room for at least one byte to read to ensure that we don't
             // get a spurious 0 that looks like EOF
             self.buffer.reserve(1);
-            if 0 == try_ready!(self.inner.read_buf(&mut self.buffer, cx)) {
+            if 0 == try_ready!(self.inner.read_buf(cx, &mut self.buffer)) {
                 self.eof = true;
             }
 

futures-util/src/io/framed_write.rs

@@ -207,7 +207,7 @@ impl<T> Sink for FramedWrite2<T>
         while !self.buffer.is_empty() {
             trace!("writing; remaining={}", self.buffer.len());
 
-            let n = try_ready!(self.inner.poll_write(&self.buffer, cx));
+            let n = try_ready!(self.inner.poll_write(cx, &self.buffer));
 
             if n == 0 {
                 return Err(io::Error::new(io::ErrorKind::WriteZero, "failed to
@@ -253,15 +253,15 @@ impl<T: AsyncRead> AsyncRead for FramedWrite2<T> {
         self.inner.initializer()
     }
 
-    fn poll_read(&mut self, buf: &mut [u8], cx: &mut task::Context)
+    fn poll_read(&mut self, cx: &mut task::Context, buf: &mut [u8])
         -> Poll<usize, io::Error>
     {
-        self.inner.poll_read(buf, cx)
+        self.inner.poll_read(cx, buf)
     }
 
-    fn poll_vectored_read(&mut self, vec: &mut [&mut IoVec], cx: &mut task::Context)
+    fn poll_vectored_read(&mut self, cx: &mut task::Context, vec: &mut [&mut IoVec])
         -> Poll<usize, io::Error>
     {
-        self.inner.poll_vectored_read(vec, cx)
+        self.inner.poll_vectored_read(cx, vec)
     }
 }

futures-util/src/io/length_delimited.rs

@@ -245,16 +245,16 @@ impl<T: io::Write> io::Write for FramedRead<T> {
 }
 
 impl<T: AsyncWrite> AsyncWrite for FramedRead<T> {
-    fn poll_write(&mut self, buf: &[u8], cx: &mut task::Context)
+    fn poll_write(&mut self, cx: &mut task::Context, buf: &[u8])
         -> Poll<usize, io::Error>
     {
-        self.inner.get_mut().poll_write(buf, cx)
+        self.inner.get_mut().poll_write(cx, buf)
     }
 
-    fn poll_vectored_write(&mut self, vec: &[&IoVec], cx: &mut task::Context)
+    fn poll_vectored_write(&mut self, cx: &mut task::Context, vec: &[&IoVec])
         -> Poll<usize, io::Error>
     {
-        self.inner.get_mut().poll_vectored_write(vec, cx)
+        self.inner.get_mut().poll_vectored_write(cx, vec)
     }
 
     fn poll_flush(&mut self, cx: &mut task::Context) -> Poll<(), io::Error> {
@@ -439,7 +439,7 @@ impl<T: AsyncWrite, B: IntoBuf> FramedWrite<T, B> {
 
         loop {
             let frame = self.frame.as_mut().unwrap();
-            try_ready!(self.inner.write_buf(frame, cx));
+            try_ready!(self.inner.write_buf(cx, frame));
 
             if !frame.has_remaining() {
                 break;
@@ -534,16 +534,16 @@ impl<T: AsyncRead, U: IntoBuf> AsyncRead for FramedWrite<T, U> {
         self.get_ref().initializer()
     }
 
-    fn poll_read(&mut self, buf: &mut [u8], cx: &mut task::Context)
+    fn poll_read(&mut self, cx: &mut task::Context, buf: &mut [u8])
         -> Poll<usize, io::Error>
     {
-        self.get_mut().poll_read(buf, cx)
+        self.get_mut().poll_read(cx, buf)
     }
 
-    fn poll_vectored_read(&mut self, vec: &mut [&mut IoVec], cx: &mut task::Context)
+    fn poll_vectored_read(&mut self, cx: &mut task::Context, vec: &mut [&mut IoVec])
         -> Poll<usize, io::Error>
     {
-        self.get_mut().poll_vectored_read(vec, cx)
+        self.get_mut().poll_vectored_read(cx, vec)
     }
 }
 

futures-util/src/io/mod.rs

@@ -47,7 +47,7 @@ pub trait AsyncReadExt: AsyncRead {
     /// The `buf` provided will have bytes read into it and the internal cursor
     /// will be advanced if any bytes were read. Note that this method typically
     /// will not reallocate the buffer provided.
-    fn read_buf<B: BufMut>(&mut self, buf: &mut B, cx: &mut task::Context)
+    fn read_buf<B: BufMut>(&mut self, cx: &mut task::Context, buf: &mut B)
         -> Poll<usize, std_io::Error>
         where Self: Sized,
     {
@@ -83,7 +83,7 @@ pub trait AsyncReadExt: AsyncRead {
                     b13.into(), b14.into(), b15.into(), b16.into(),
                 ];
                 let n = buf.bytes_vec_mut(&mut bufs);
-                try_ready!(self.poll_vectored_read(&mut bufs[..n], cx))
+                try_ready!(self.poll_vectored_read(cx, &mut bufs[..n]))
             };
 
             buf.advance_mut(n);
@@ -133,7 +133,7 @@ pub trait AsyncWriteExt: AsyncWrite {
     ///
     /// Note that this method will advance the `buf` provided automatically by
     /// the number of bytes written.
-    fn write_buf<B: Buf>(&mut self, buf: &mut B, cx: &mut task::Context)
+    fn write_buf<B: Buf>(&mut self, cx: &mut task::Context, buf: &mut B)
         -> Poll<usize, std_io::Error>
         where Self: Sized,
     {
@@ -149,7 +149,7 @@ pub trait AsyncWriteExt: AsyncWrite {
             let iovec = <&IoVec>::from(DUMMY);
             let mut bufs = [iovec; 64];
             let n = buf.bytes_vec(&mut bufs);
-            try_ready!(self.poll_vectored_write(&bufs[..n], cx))
+            try_ready!(self.poll_vectored_write(cx, &bufs[..n]))
         };
         buf.advance(n);
         Ok(Async::Ready(n))

futures-util/src/io/read.rs

@@ -45,7 +45,7 @@ impl<R, T> Future for Read<R, T>
     fn poll(&mut self, cx: &mut task::Context) -> Poll<(R, T, usize), io::Error> {
         let nread = match self.state {
             State::Pending { ref mut rd, ref mut buf } =>
-                try_ready!(rd.poll_read(&mut buf.as_mut()[..], cx)),
+                try_ready!(rd.poll_read(cx, &mut buf.as_mut()[..])),
             State::Empty => panic!("poll a Read after it's done"),
         };
 

futures-util/src/io/read_exact.rs

@@ -65,7 +65,7 @@ impl<A, T> Future for ReadExact<A, T>
             State::Reading { ref mut a, ref mut buf, ref mut pos } => {
                 let buf = buf.as_mut();
                 while *pos < buf.len() {
-                    let n = try_ready!(a.poll_read(&mut buf[*pos..], cx));
+                    let n = try_ready!(a.poll_read(cx, &mut buf[*pos..]));
                     *pos += n;
                     if n == 0 {
                         return Err(eof())

futures-util/src/io/read_to_end.rs

@@ -38,8 +38,8 @@ pub fn read_to_end<A>(a: A, buf: Vec<u8>) -> ReadToEnd<A>
 {
     ReadToEnd {
         state: State::Reading {
-            a: a,
-            buf: buf,
+            a,
+            buf,
         }
     }
 }
@@ -61,7 +61,7 @@ impl<'a> Drop for Guard<'a> {
 //
 // Because we're extending the buffer with uninitialized data for trusted
 // readers, we need to make sure to truncate that if any of this panics.
-fn read_to_end_internal<R: AsyncRead + ?Sized>(r: &mut R, buf: &mut Vec<u8>, cx: &mut task::Context)
+fn read_to_end_internal<R: AsyncRead + ?Sized>(r: &mut R, cx: &mut task::Context, buf: &mut Vec<u8>)
     -> Poll<usize, io::Error>
 {
     let start_len = buf.len();
@@ -77,7 +77,7 @@ fn read_to_end_internal<R: AsyncRead + ?Sized>(r: &mut R, buf: &mut Vec<u8>, cx:
             }
         }
 
-        match r.poll_read(&mut g.buf[g.len..], cx) {
+        match r.poll_read(cx, &mut g.buf[g.len..]) {
             Ok(Async::Ready(0)) => {
                 ret = Ok(Async::Ready(g.len - start_len));
                 break;
@@ -107,7 +107,7 @@ impl<A> Future for ReadToEnd<A>
                 // If we get `Ok`, then we know the stream hit EOF and we're done. If we
                 // hit "would block" then all the read data so far is in our buffer, and
                 // otherwise we propagate errors
-                try_ready!(read_to_end_internal(a, buf, cx));
+                try_ready!(read_to_end_internal(a, cx, buf));
             },
             State::Empty => panic!("poll ReadToEnd after it's done"),
         }