s/Generator/Coroutine/

Author: oli-obk

tests/fail/generator-pinned-moved.rs

@@ -2,11 +2,11 @@
 #![feature(generators, generator_trait)]
 
 use std::{
-    ops::{Generator, GeneratorState},
+    ops::{Coroutine, CoroutineState},
     pin::Pin,
 };
 
-fn firstn() -> impl Generator<Yield = u64, Return = ()> {
+fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
     static move || {
         let mut num = 0;
         let num = &mut num;
@@ -17,26 +17,26 @@ fn firstn() -> impl Generator<Yield = u64, Return = ()> {
     }
 }
 
-struct GeneratorIteratorAdapter<G>(G);
+struct CoroutineIteratorAdapter<G>(G);
 
-impl<G> Iterator for GeneratorIteratorAdapter<G>
+impl<G> Iterator for CoroutineIteratorAdapter<G>
 where
-    G: Generator<Return = ()>,
+    G: Coroutine<Return = ()>,
 {
     type Item = G::Yield;
 
     fn next(&mut self) -> Option<Self::Item> {
         let me = unsafe { Pin::new_unchecked(&mut self.0) };
         match me.resume(()) {
-            GeneratorState::Yielded(x) => Some(x),
-            GeneratorState::Complete(_) => None,
+            CoroutineState::Yielded(x) => Some(x),
+            CoroutineState::Complete(_) => None,
         }
     }
 }
 
 fn main() {
     let mut generator_iterator_2 = {
-        let mut generator_iterator = Box::new(GeneratorIteratorAdapter(firstn()));
+        let mut generator_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
         generator_iterator.next(); // pin it
 
         Box::new(*generator_iterator) // move it

tests/fail/generator-pinned-moved.stderr

@@ -9,7 +9,7 @@ LL |         *num += 1;
 help: ALLOC was allocated here:
   --> $DIR/generator-pinned-moved.rs:LL:CC
    |
-LL |         let mut generator_iterator = Box::new(GeneratorIteratorAdapter(firstn()));
+LL |         let mut generator_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: ALLOC was deallocated here:
   --> $DIR/generator-pinned-moved.rs:LL:CC
@@ -18,12 +18,12 @@ LL |     }; // *deallocate* generator_iterator
    |     ^
    = note: BACKTRACE (of the first span):
    = note: inside closure at $DIR/generator-pinned-moved.rs:LL:CC
-note: inside `<GeneratorIteratorAdapter<{static generator@$DIR/generator-pinned-moved.rs:LL:CC}> as std::iter::Iterator>::next`
+note: inside `<CoroutineIteratorAdapter<{static generator@$DIR/generator-pinned-moved.rs:LL:CC}> as std::iter::Iterator>::next`
   --> $DIR/generator-pinned-moved.rs:LL:CC
    |
 LL |         match me.resume(()) {
    |               ^^^^^^^^^^^^^
-   = note: inside `<std::boxed::Box<GeneratorIteratorAdapter<{static generator@$DIR/generator-pinned-moved.rs:LL:CC}>> as std::iter::Iterator>::next` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+   = note: inside `<std::boxed::Box<CoroutineIteratorAdapter<{static generator@$DIR/generator-pinned-moved.rs:LL:CC}>> as std::iter::Iterator>::next` at RUSTLIB/alloc/src/boxed.rs:LL:CC
 note: inside `main`
   --> $DIR/generator-pinned-moved.rs:LL:CC
    |

tests/pass/generator.rs

@@ -5,8 +5,8 @@
 use std::fmt::Debug;
 use std::mem::ManuallyDrop;
 use std::ops::{
-    Generator,
-    GeneratorState::{self, *},
+    Coroutine,
+    CoroutineState::{self, *},
 };
 use std::pin::Pin;
 use std::ptr;
@@ -15,7 +15,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 fn basic() {
     fn finish<T>(mut amt: usize, self_referential: bool, mut t: T) -> T::Return
     where
-        T: Generator<Yield = usize>,
+        T: Coroutine<Yield = usize>,
     {
         // We are not moving the `t` around until it gets dropped, so this is okay.
         let mut t = unsafe { Pin::new_unchecked(&mut t) };
@@ -27,10 +27,10 @@ fn basic() {
                 let _ = unsafe { ManuallyDrop::new(ptr::read(t.as_mut().get_unchecked_mut())) };
             }
             match state {
-                GeneratorState::Yielded(y) => {
+                CoroutineState::Yielded(y) => {
                     amt -= y;
                 }
-                GeneratorState::Complete(ret) => {
+                CoroutineState::Complete(ret) => {
                     assert_eq!(amt, 0);
                     return ret;
                 }
@@ -134,9 +134,9 @@ fn basic() {
 }
 
 fn smoke_resume_arg() {
-    fn drain<G: Generator<R, Yield = Y> + Unpin, R, Y>(
+    fn drain<G: Coroutine<R, Yield = Y> + Unpin, R, Y>(
         gen: &mut G,
-        inout: Vec<(R, GeneratorState<Y, G::Return>)>,
+        inout: Vec<(R, CoroutineState<Y, G::Return>)>,
     ) where
         Y: Debug + PartialEq,
         G::Return: Debug + PartialEq,

tests/pass/stacked-borrows/generators-self-referential.rs

@@ -3,11 +3,11 @@
 #![feature(generators, generator_trait)]
 
 use std::{
-    ops::{Generator, GeneratorState},
+    ops::{Coroutine, CoroutineState},
     pin::Pin,
 };
 
-fn firstn() -> impl Generator<Yield = u64, Return = ()> {
+fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
     static move || {
         let mut num = 0;
         let num = &mut num;
@@ -27,7 +27,7 @@ fn main() {
     let mut generator_iterator = firstn();
     let mut pin = unsafe { Pin::new_unchecked(&mut generator_iterator) };
     let mut sum = 0;
-    while let GeneratorState::Yielded(x) = pin.as_mut().resume(()) {
+    while let CoroutineState::Yielded(x) = pin.as_mut().resume(()) {
         sum += x;
     }
     assert_eq!(sum, 3);

tests/pass/track-caller-attribute.rs

@@ -4,7 +4,7 @@
 #![feature(generator_trait)]
 #![feature(generators)]
 
-use std::ops::{Generator, GeneratorState};
+use std::ops::{Coroutine, CoroutineState};
 use std::panic::Location;
 use std::pin::Pin;
 
@@ -212,21 +212,21 @@ fn test_closure() {
 
 fn test_generator() {
     #[track_caller]
-    fn mono_generator<F: Generator<String, Yield = (&'static str, String, Loc), Return = ()>>(
+    fn mono_generator<F: Coroutine<String, Yield = (&'static str, String, Loc), Return = ()>>(
         val: Pin<&mut F>,
     ) -> (&'static str, String, Loc) {
         match val.resume("Mono".to_string()) {
-            GeneratorState::Yielded(val) => val,
+            CoroutineState::Yielded(val) => val,
             _ => unreachable!(),
         }
     }
 
     #[track_caller]
     fn dyn_generator(
-        val: Pin<&mut dyn Generator<String, Yield = (&'static str, String, Loc), Return = ()>>,
+        val: Pin<&mut dyn Coroutine<String, Yield = (&'static str, String, Loc), Return = ()>>,
     ) -> (&'static str, String, Loc) {
         match val.resume("Dyn".to_string()) {
-            GeneratorState::Yielded(val) => val,
+            CoroutineState::Yielded(val) => val,
             _ => unreachable!(),
         }
     }
@@ -241,7 +241,7 @@ fn test_generator() {
     let (dyn_ret, dyn_arg, dyn_loc) = dyn_generator(pinned.as_mut());
     assert_eq!(dyn_ret, "first");
     assert_eq!(dyn_arg, "Dyn".to_string());
-    // The `Generator` trait does not have `#[track_caller]` on `resume`, so
+    // The `Coroutine` trait does not have `#[track_caller]` on `resume`, so
     // this will not match.
     assert_ne!(dyn_loc.file(), file!());
 
@@ -258,7 +258,7 @@ fn test_generator() {
     let non_tracked_generator = || { yield Location::caller(); };
     let non_tracked_line = line!() - 1; // This is the line of the generator, not its caller
     let non_tracked_loc = match Box::pin(non_tracked_generator).as_mut().resume(()) {
-        GeneratorState::Yielded(val) => val,
+        CoroutineState::Yielded(val) => val,
         _ => unreachable!(),
     };
     assert_eq!(non_tracked_loc.file(), file!());