s/generator/coroutine/

Author: oli-obk

src/helpers.rs

@@ -492,7 +492,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                     // `Variants::Multiple`.
                     match v.layout.variants {
                         Variants::Multiple { .. } => {
-                            // A multi-variant enum, or generator, or so.
+                            // A multi-variant enum, or coroutine, or so.
                             // Treat this like a union: without reading from memory,
                             // we cannot determine the variant we are in. Reading from
                             // memory would be subject to Stacked Borrows rules, leading

tests/fail/generator-pinned-moved.rs

@@ -1,5 +1,5 @@
 //@compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
 use std::{
     ops::{Coroutine, CoroutineState},
@@ -35,12 +35,12 @@ where
 }
 
 fn main() {
-    let mut generator_iterator_2 = {
-        let mut generator_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
-        generator_iterator.next(); // pin it
+    let mut coroutine_iterator_2 = {
+        let mut coroutine_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
+        coroutine_iterator.next(); // pin it
 
-        Box::new(*generator_iterator) // move it
-    }; // *deallocate* generator_iterator
+        Box::new(*coroutine_iterator) // move it
+    }; // *deallocate* coroutine_iterator
 
-    generator_iterator_2.next(); // and use moved value
+    coroutine_iterator_2.next(); // and use moved value
 }

tests/fail/generator-pinned-moved.stderr

@@ -9,25 +9,25 @@ LL |         *num += 1;
 help: ALLOC was allocated here:
   --> $DIR/generator-pinned-moved.rs:LL:CC
    |
-LL |         let mut generator_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
+LL |         let mut coroutine_iterator = Box::new(CoroutineIteratorAdapter(firstn()));
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: ALLOC was deallocated here:
   --> $DIR/generator-pinned-moved.rs:LL:CC
    |
-LL |     }; // *deallocate* generator_iterator
+LL |     }; // *deallocate* coroutine_iterator
    |     ^
    = note: BACKTRACE (of the first span):
    = note: inside closure at $DIR/generator-pinned-moved.rs:LL:CC
-note: inside `<CoroutineIteratorAdapter<{static generator@$DIR/generator-pinned-moved.rs:LL:CC}> as std::iter::Iterator>::next`
+note: inside `<CoroutineIteratorAdapter<{static coroutine@$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<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 `<std::boxed::Box<CoroutineIteratorAdapter<{static coroutine@$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
    |
-LL |     generator_iterator_2.next(); // and use moved value
+LL |     coroutine_iterator_2.next(); // and use moved value
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace

tests/pass/generator.rs renamed to tests/pass/coroutine.rs

@@ -1,6 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-#![feature(generators, generator_trait, never_type)]
+#![feature(coroutines, coroutine_trait, never_type)]
 
 use std::fmt::Debug;
 use std::mem::ManuallyDrop;
@@ -21,8 +21,8 @@ fn basic() {
         let mut t = unsafe { Pin::new_unchecked(&mut t) };
         loop {
             let state = t.as_mut().resume(());
-            // Test if the generator is valid (according to type invariants).
-            // For self-referential generators however this is UB!
+            // Test if the coroutine is valid (according to type invariants).
+            // For self-referential coroutines however this is UB!
             if !self_referential {
                 let _ = unsafe { ManuallyDrop::new(ptr::read(t.as_mut().get_unchecked_mut())) };
             }
@@ -86,7 +86,7 @@ fn basic() {
         yield 1;
     });
 
-    // also test self-referential generators
+    // also test self-referential coroutines
     assert_eq!(
         finish(5, true, static || {
             let mut x = 5;
@@ -145,7 +145,7 @@ fn smoke_resume_arg() {
 
         for (input, out) in inout {
             assert_eq!(gen.as_mut().resume(input), out);
-            // Test if the generator is valid (according to type invariants).
+            // Test if the coroutine is valid (according to type invariants).
             let _ = unsafe { ManuallyDrop::new(ptr::read(gen.as_mut().get_unchecked_mut())) };
         }
     }

tests/pass/move-data-across-await-point.rs

@@ -15,7 +15,7 @@ async fn data_moved_async() {
         // `raw_pointer` points to the original location where the Vec was stored in the caller.
         // `data` is where that Vec (to be precise, its ptr+capacity+len on-stack data)
         // got moved to. Those will usually not be the same since the Vec got moved twice
-        // (into the function call, and then into the generator upvar).
+        // (into the function call, and then into the coroutine upvar).
         assert_ne!(raw_pointer, raw_pointer2);
         unsafe {
             // This writes into the `x` in `data_moved_async`, re-initializing it.

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

@@ -1,6 +1,6 @@
 // See https://github.com/rust-lang/unsafe-code-guidelines/issues/148:
 // this fails when Stacked Borrows is strictly applied even to `!Unpin` types.
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
 use std::{
     ops::{Coroutine, CoroutineState},
@@ -24,8 +24,8 @@ fn firstn() -> impl Coroutine<Yield = u64, Return = ()> {
 }
 
 fn main() {
-    let mut generator_iterator = firstn();
-    let mut pin = unsafe { Pin::new_unchecked(&mut generator_iterator) };
+    let mut coroutine_iterator = firstn();
+    let mut pin = unsafe { Pin::new_unchecked(&mut coroutine_iterator) };
     let mut sum = 0;
     while let CoroutineState::Yielded(x) = pin.as_mut().resume(()) {
         sum += x;

tests/pass/stacked-borrows/stacked-borrows.rs

@@ -223,7 +223,7 @@ fn wide_raw_ptr_in_tuple() {
 fn not_unpin_not_protected() {
     // `&mut !Unpin`, at least for now, does not get `noalias` nor `dereferenceable`, so we also
     // don't add protectors. (We could, but until we have a better idea for where we want to go with
-    // the self-referential-generator situation, it does not seem worth the potential trouble.)
+    // the self-referential-coroutine situation, it does not seem worth the potential trouble.)
     use std::marker::PhantomPinned;
 
     pub struct NotUnpin(i32, PhantomPinned);

tests/pass/track-caller-attribute.rs

@@ -1,8 +1,8 @@
 #![feature(core_intrinsics)]
 #![feature(stmt_expr_attributes)]
 #![feature(closure_track_caller)]
-#![feature(generator_trait)]
-#![feature(generators)]
+#![feature(coroutine_trait)]
+#![feature(coroutines)]
 
 use std::ops::{Coroutine, CoroutineState};
 use std::panic::Location;
@@ -210,9 +210,9 @@ fn test_closure() {
     assert_eq!(non_tracked_loc.column(), 33);
 }
 
-fn test_generator() {
+fn test_coroutine() {
     #[track_caller]
-    fn mono_generator<F: Coroutine<String, Yield = (&'static str, String, Loc), Return = ()>>(
+    fn mono_coroutine<F: Coroutine<String, Yield = (&'static str, String, Loc), Return = ()>>(
         val: Pin<&mut F>,
     ) -> (&'static str, String, Loc) {
         match val.resume("Mono".to_string()) {
@@ -222,7 +222,7 @@ fn test_generator() {
     }
 
     #[track_caller]
-    fn dyn_generator(
+    fn dyn_coroutine(
         val: Pin<&mut dyn Coroutine<String, Yield = (&'static str, String, Loc), Return = ()>>,
     ) -> (&'static str, String, Loc) {
         match val.resume("Dyn".to_string()) {
@@ -232,32 +232,32 @@ fn test_generator() {
     }
 
     #[rustfmt::skip]
-    let generator = #[track_caller] |arg: String| {
+    let coroutine = #[track_caller] |arg: String| {
         yield ("first", arg.clone(), Location::caller());
         yield ("second", arg.clone(), Location::caller());
     };
 
-    let mut pinned = Box::pin(generator);
-    let (dyn_ret, dyn_arg, dyn_loc) = dyn_generator(pinned.as_mut());
+    let mut pinned = Box::pin(coroutine);
+    let (dyn_ret, dyn_arg, dyn_loc) = dyn_coroutine(pinned.as_mut());
     assert_eq!(dyn_ret, "first");
     assert_eq!(dyn_arg, "Dyn".to_string());
     // The `Coroutine` trait does not have `#[track_caller]` on `resume`, so
     // this will not match.
     assert_ne!(dyn_loc.file(), file!());
 
-    let (mono_ret, mono_arg, mono_loc) = mono_generator(pinned.as_mut());
+    let (mono_ret, mono_arg, mono_loc) = mono_coroutine(pinned.as_mut());
     let mono_line = line!() - 1;
     assert_eq!(mono_ret, "second");
-    // The generator ignores the argument to the second `resume` call
+    // The coroutine ignores the argument to the second `resume` call
     assert_eq!(mono_arg, "Dyn".to_string());
     assert_eq!(mono_loc.file(), file!());
     assert_eq!(mono_loc.line(), mono_line);
     assert_eq!(mono_loc.column(), 42);
 
     #[rustfmt::skip]
-    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(()) {
+    let non_tracked_coroutine = || { yield Location::caller(); };
+    let non_tracked_line = line!() - 1; // This is the line of the coroutine, not its caller
+    let non_tracked_loc = match Box::pin(non_tracked_coroutine).as_mut().resume(()) {
         CoroutineState::Yielded(val) => val,
         _ => unreachable!(),
     };
@@ -272,5 +272,5 @@ fn main() {
     test_trait_obj();
     test_trait_obj2();
     test_closure();
-    test_generator();
+    test_coroutine();
 }

tests/pass/tree_borrows/tree-borrows.rs

@@ -315,7 +315,7 @@ fn wide_raw_ptr_in_tuple() {
 fn not_unpin_not_protected() {
     // `&mut !Unpin`, at least for now, does not get `noalias` nor `dereferenceable`, so we also
     // don't add protectors. (We could, but until we have a better idea for where we want to go with
-    // the self-referential-generator situation, it does not seem worth the potential trouble.)
+    // the self-referential-coroutine situation, it does not seem worth the potential trouble.)
     use std::marker::PhantomPinned;
 
     pub struct NotUnpin(i32, PhantomPinned);