hyperium
diff --git a/‎src/client/dispatch.rs‎
Lines changed: 9 additions & 13 deletions b/‎src/client/dispatch.rs‎
Lines changed: 9 additions & 13 deletions
diff --git a/‎src/proto/h1/dispatch.rs‎
Lines changed: 6 additions & 8 deletions b/‎src/proto/h1/dispatch.rs‎
Lines changed: 6 additions & 8 deletions
diff --git a/‎src/proto/h2/client.rs‎
Lines changed: 1 addition & 1 deletion b/‎src/proto/h2/client.rs‎
Lines changed: 1 addition & 1 deletion
@@ -138,25 +138,22 @@ impl<T, U> Clone for UnboundedSender<T, U> {
  }
 }
 
-#[pin_project::pin_project(PinnedDrop)]
 pub(crate) struct Receiver<T, U> {
- #[pin]
  inner: mpsc::UnboundedReceiver<Envelope<T, U>>,
  taker: want::Taker,
 }
 
 impl<T, U> Receiver<T, U> {
- pub(crate) fn poll_next(
- self: Pin<&mut Self>,
+ pub(crate) fn poll_recv(
+ &mut self,
  cx: &mut task::Context<'_>,
  ) -> Poll<Option<(T, Callback<T, U>)>> {
- let mut this = self.project();
- match this.inner.poll_recv(cx) {
+ match self.inner.poll_recv(cx) {
  Poll::Ready(item) => {
  Poll::Ready(item.map(|mut env| env.0.take().expect("envelope not dropped")))
  }
  Poll::Pending => {
- this.taker.want();
+ self.taker.want();
  Poll::Pending
  }
  }
@@ -177,12 +174,11 @@ impl<T, U> Receiver<T, U> {
  }
 }
 
-#[pin_project::pinned_drop]
-impl<T, U> PinnedDrop for Receiver<T, U> {
- fn drop(mut self: Pin<&mut Self>) {
+impl<T, U> Drop for Receiver<T, U> {
+ fn drop(&mut self) {
  // Notify the giver about the closure first, before dropping
  // the mpsc::Receiver.
- self.as_mut().taker.cancel();
+ self.taker.cancel();
  }
 }
 
@@ -279,8 +275,8 @@ mod tests {
  impl<T, U> Future for Receiver<T, U> {
  type Output = Option<(T, Callback<T, U>)>;
 
- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
- self.poll_next(cx)
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ self.poll_recv(cx)
  }
  }
 
 
@@ -44,10 +44,8 @@ cfg_server! {
 }
 
 cfg_client! {
- #[pin_project::pin_project]
  pub(crate) struct Client<B> {
  callback: Option<crate::client::dispatch::Callback<Request<B>, http::Response<Body>>>,
- #[pin]
  rx: ClientRx<B>,
  rx_closed: bool,
  }
@@ -557,12 +555,12 @@ cfg_client! {
  type RecvItem = crate::proto::ResponseHead;
 
  fn poll_msg(
- self: Pin<&mut Self>,
+ mut self: Pin<&mut Self>,
  cx: &mut task::Context<'_>,
  ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), crate::common::Never>>> {
- let this = self.project();
- debug_assert!(!*this.rx_closed);
- match this.rx.poll_next(cx) {
+ let mut this = self.as_mut();
+ debug_assert!(!this.rx_closed);
+ match this.rx.poll_recv(cx) {
  Poll::Ready(Some((req, mut cb))) => {
  // check that future hasn't been canceled already
  match cb.poll_canceled(cx) {
@@ -578,15 +576,15 @@ cfg_client! {
  headers: parts.headers,
  extensions: parts.extensions,
  };
- *this.callback = Some(cb);
+ this.callback = Some(cb);
  Poll::Ready(Some(Ok((head, body))))
  }
  }
  }
  Poll::Ready(None) => {
  // user has dropped sender handle
  trace!("client tx closed");
- *this.rx_closed = true;
+ this.rx_closed = true;
  Poll::Ready(None)
  }
  Poll::Pending => Poll::Pending,
 
@@ -213,7 +213,7 @@ where
  }
  };
 
- match Pin::new(&mut self.req_rx).poll_next(cx) {
+ match self.req_rx.poll_recv(cx) {
  Poll::Ready(Some((req, cb))) => {
  // check that future hasn't been canceled already
  if cb.is_canceled() {
Original file line number	Diff line number	Diff line change
`@@ -138,25 +138,22 @@ impl<T, U> Clone for UnboundedSender<T, U> {`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`-#[pin_project::pin_project(PinnedDrop)]`
`142`	`141`	`pub(crate) struct Receiver<T, U> {`
`143`		`- #[pin]`
`144`	`142`	`inner: mpsc::UnboundedReceiver<Envelope<T, U>>,`
`145`	`143`	`taker: want::Taker,`
`146`	`144`	`}`
`147`	`145`
`148`	`146`	`impl<T, U> Receiver<T, U> {`
`149`		`- pub(crate) fn poll_next(`
`150`		`- self: Pin<&mut Self>,`
	`147`	`+ pub(crate) fn poll_recv(`
	`148`	`+ &mut self,`
`151`	`149`	`cx: &mut task::Context<'_>,`
`152`	`150`	`) -> Poll<Option<(T, Callback<T, U>)>> {`
`153`		`- let mut this = self.project();`
`154`		`- match this.inner.poll_recv(cx) {`
	`151`	`+ match self.inner.poll_recv(cx) {`
`155`	`152`	`Poll::Ready(item) => {`
`156`	`153`	`Poll::Ready(item.map(\|mut env\| env.0.take().expect("envelope not dropped")))`
`157`	`154`	`}`
`158`	`155`	`Poll::Pending => {`
`159`		`- this.taker.want();`
	`156`	`+ self.taker.want();`
`160`	`157`	`Poll::Pending`
`161`	`158`	`}`
`162`	`159`	`}`
`@@ -177,12 +174,11 @@ impl<T, U> Receiver<T, U> {`
`177`	`174`	`}`
`178`	`175`	`}`
`179`	`176`
`180`		`-#[pin_project::pinned_drop]`
`181`		`-impl<T, U> PinnedDrop for Receiver<T, U> {`
`182`		`- fn drop(mut self: Pin<&mut Self>) {`
	`177`	`+impl<T, U> Drop for Receiver<T, U> {`
	`178`	`+ fn drop(&mut self) {`
`183`	`179`	`// Notify the giver about the closure first, before dropping`
`184`	`180`	`// the mpsc::Receiver.`
`185`		`- self.as_mut().taker.cancel();`
	`181`	`+ self.taker.cancel();`
`186`	`182`	`}`
`187`	`183`	`}`
`188`	`184`
`@@ -279,8 +275,8 @@ mod tests {`
`279`	`275`	`impl<T, U> Future for Receiver<T, U> {`
`280`	`276`	`type Output = Option<(T, Callback<T, U>)>;`
`281`	`277`
`282`		`- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {`
`283`		`- self.poll_next(cx)`
	`278`	`+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {`
	`279`	`+ self.poll_recv(cx)`
`284`	`280`	`}`
`285`	`281`	`}`
`286`	`282`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ where`
`213`	`213`	`}`
`214`	`214`	`};`
`215`	`215`
`216`		`- match Pin::new(&mut self.req_rx).poll_next(cx) {`
	`216`	`+ match self.req_rx.poll_recv(cx) {`
`217`	`217`	`Poll::Ready(Some((req, cb))) => {`
`218`	`218`	`// check that future hasn't been canceled already`
`219`	`219`	`if cb.is_canceled() {`