refactor(lib): Switch from pin-project to pin-project-lite (#2566)

Note the practical affects of this change:

- Dependency count with --features full dropped from 65 to 55.
- Time to compile after a clean dropped from 48s to 35s (on a pretty underpowered VM).

Closes #2388

src/server/shutdown.rs

@@ -1,33 +1,36 @@
 use std::error::Error as StdError;
 
-use pin_project::pin_project;
+use pin_project_lite::pin_project;
 use tokio::io::{AsyncRead, AsyncWrite};
 
-use super::conn::{SpawnAll, UpgradeableConnection, Watcher};
 use super::accept::Accept;
+use super::conn::{SpawnAll, UpgradeableConnection, Watcher};
 use crate::body::{Body, HttpBody};
 use crate::common::drain::{self, Draining, Signal, Watch, Watching};
 use crate::common::exec::{ConnStreamExec, NewSvcExec};
 use crate::common::{task, Future, Pin, Poll, Unpin};
 use crate::service::{HttpService, MakeServiceRef};
 
-#[allow(missing_debug_implementations)]
-#[pin_project]
-pub struct Graceful<I, S, F, E> {
-    #[pin]
-    state: State<I, S, F, E>,
+pin_project! {
+    #[allow(missing_debug_implementations)]
+    pub struct Graceful<I, S, F, E> {
+        #[pin]
+        state: State<I, S, F, E>,
+    }
 }
 
-#[pin_project(project = StateProj)]
-pub(super) enum State<I, S, F, E> {
-    Running {
-        drain: Option<(Signal, Watch)>,
-        #[pin]
-        spawn_all: SpawnAll<I, S, E>,
-        #[pin]
-        signal: F,
-    },
-    Draining(Draining),
+pin_project! {
+    #[project = StateProj]
+    pub(super) enum State<I, S, F, E> {
+        Running {
+            drain: Option<(Signal, Watch)>,
+            #[pin]
+            spawn_all: SpawnAll<I, S, E>,
+            #[pin]
+            signal: F,
+        },
+        Draining { draining: Draining },
+    }
 }
 
 impl<I, S, F, E> Graceful<I, S, F, E> {
@@ -71,14 +74,16 @@ where
                         Poll::Ready(()) => {
                             debug!("signal received, starting graceful shutdown");
                             let sig = drain.take().expect("drain channel").0;
-                            State::Draining(sig.drain())
+                            State::Draining {
+                                draining: sig.drain(),
+                            }
                         }
                         Poll::Pending => {
                             let watch = drain.as_ref().expect("drain channel").1.clone();
                             return spawn_all.poll_watch(cx, &GracefulWatcher(watch));
                         }
                     },
-                    StateProj::Draining(ref mut draining) => {
+                    StateProj::Draining { ref mut draining } => {
                         return Pin::new(draining).poll(cx).map(Ok);
                     }
                 }