Make Barrier::wait future Send (#1611)

It wasn't before. Now it is. And that is better.

tokio-sync/src/barrier.rs

@@ -83,6 +83,9 @@ impl Barrier {
         // deadlock even if another future is concurrently holding the lock.
         // It is _desireable_ to do so as synchronous Mutexes are, at least in theory, faster than
         // the asynchronous counter-parts, so we should use them where possible [citation needed].
+        // NOTE: the extra scope here is so that the compiler doesn't think `state` is held across
+        // a yield point, and thus marks the returned future as !Send.
+        let generation = {
             let mut state = self.state.lock().unwrap();
             let generation = state.generation;
             state.arrived += 1;
@@ -98,7 +101,8 @@ impl Barrier {
                 return BarrierWaitResult(true);
             }
 
-        drop(state);
+            generation
+        };
 
         // we're going to have to wait for the last of the generation to arrive
         let mut wait = self.wait.clone();

tokio-sync/tests/barrier.rs

@@ -4,6 +4,13 @@ use tokio_sync::Barrier;
 use tokio_test::task::spawn;
 use tokio_test::{assert_pending, assert_ready};
 
+struct IsSend<T: Send>(T);
+#[test]
+fn barrier_future_is_send() {
+    let b = Barrier::new(0);
+    IsSend(b.wait());
+}
+
 #[test]
 fn zero_does_not_block() {
     let b = Barrier::new(0);