Auto merge of #116958 - oli-obk:coro, r=pnkfelix

rename Generator to Coroutine

implements https://github.com/rust-lang/compiler-team/issues/682

While I did an automated replacement, I went through all changes manually to avoid renaming things like "id generators", "code generator", ...

I renamed files where that was necessary due to the contents referring to the crate name itself (mir opt, codegen or debuginfo tests), or required by tidy (feature gate docs)

* [x] rename various remaining abbreviated references to generators.
* [x] rename files
* [x] rename folders
* [x] add renamed feature: `generators`, ...

r? `@ghost`

6 files changed, 42 insertions, 42 deletions

diff --git a/compiler/rustc_error_codes/src/error_codes/E0626.md b/compiler/rustc_error_codes/src/error_codes/E0626.md
index cc6e03d1ca7..e2534415d83 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0626.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0626.md
@@ -1,11 +1,11 @@
-This error occurs because a borrow in a generator persists across a
+This error occurs because a borrow in a coroutine persists across a
 yield point.
 
 Erroneous code example:
 
 ```compile_fail,E0626
-# #![feature(generators, generator_trait, pin)]
-# use std::ops::Generator;
+# #![feature(coroutines, coroutine_trait, pin)]
+# use std::ops::Coroutine;
 # use std::pin::Pin;
 let mut b = || {
     let a = &String::new(); // <-- This borrow...
@@ -23,8 +23,8 @@ resolve the previous example by removing the borrow and just storing
 the integer by value:
 
 ```
-# #![feature(generators, generator_trait, pin)]
-# use std::ops::Generator;
+# #![feature(coroutines, coroutine_trait, pin)]
+# use std::ops::Coroutine;
 # use std::pin::Pin;
 let mut b = || {
     let a = 3;
@@ -41,8 +41,8 @@ in those cases, something like the `Rc` or `Arc` types may be useful.
 This error also frequently arises with iteration:
 
 ```compile_fail,E0626
-# #![feature(generators, generator_trait, pin)]
-# use std::ops::Generator;
+# #![feature(coroutines, coroutine_trait, pin)]
+# use std::ops::Coroutine;
 # use std::pin::Pin;
 let mut b = || {
   let v = vec![1,2,3];
@@ -57,8 +57,8 @@ Such cases can sometimes be resolved by iterating "by value" (or using
 `into_iter()`) to avoid borrowing:
 
 ```
-# #![feature(generators, generator_trait, pin)]
-# use std::ops::Generator;
+# #![feature(coroutines, coroutine_trait, pin)]
+# use std::ops::Coroutine;
 # use std::pin::Pin;
 let mut b = || {
   let v = vec![1,2,3];
@@ -72,8 +72,8 @@ Pin::new(&mut b).resume(());
 If taking ownership is not an option, using indices can work too:
 
 ```
-# #![feature(generators, generator_trait, pin)]
-# use std::ops::Generator;
+# #![feature(coroutines, coroutine_trait, pin)]
+# use std::ops::Coroutine;
 # use std::pin::Pin;
 let mut b = || {
   let v = vec![1,2,3];
diff --git a/compiler/rustc_error_codes/src/error_codes/E0627.md b/compiler/rustc_error_codes/src/error_codes/E0627.md
index 21358e1e567..5d366f78fc5 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0627.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0627.md
@@ -1,28 +1,28 @@
-A yield expression was used outside of the generator literal.
+A yield expression was used outside of the coroutine literal.
 
 Erroneous code example:
 
 ```compile_fail,E0627
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
-fn fake_generator() -> &'static str {
+fn fake_coroutine() -> &'static str {
     yield 1;
     return "foo"
 }
 
 fn main() {
-    let mut generator = fake_generator;
+    let mut coroutine = fake_coroutine;
 }
 ```
 
-The error occurs because keyword `yield` can only be used inside the generator
-literal. This can be fixed by constructing the generator correctly.
+The error occurs because keyword `yield` can only be used inside the coroutine
+literal. This can be fixed by constructing the coroutine correctly.
 
 ```
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
 fn main() {
-    let mut generator = || {
+    let mut coroutine = || {
         yield 1;
         return "foo"
     };
diff --git a/compiler/rustc_error_codes/src/error_codes/E0628.md b/compiler/rustc_error_codes/src/error_codes/E0628.md
index 40040c9a56a..ce19bcd56cc 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0628.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0628.md
@@ -1,13 +1,13 @@
-More than one parameter was used for a generator.
+More than one parameter was used for a coroutine.
 
 Erroneous code example:
 
 ```compile_fail,E0628
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
 fn main() {
-    let generator = |a: i32, b: i32| {
-        // error: too many parameters for a generator
+    let coroutine = |a: i32, b: i32| {
+        // error: too many parameters for a coroutine
         // Allowed only 0 or 1 parameter
         yield a;
     };
@@ -15,15 +15,15 @@ fn main() {
 ```
 
 At present, it is not permitted to pass more than one explicit
-parameter for a generator.This can be fixed by using
-at most 1 parameter for the generator. For example, we might resolve
+parameter for a coroutine.This can be fixed by using
+at most 1 parameter for the coroutine. For example, we might resolve
 the previous example by passing only one parameter.
 
 ```
-#![feature(generators, generator_trait)]
+#![feature(coroutines, coroutine_trait)]
 
 fn main() {
-    let generator = |a: i32| {
+    let coroutine = |a: i32| {
         yield a;
     };
 }
diff --git a/compiler/rustc_error_codes/src/error_codes/E0698.md b/compiler/rustc_error_codes/src/error_codes/E0698.md
index 9bc652e642f..d0649712936 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0698.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0698.md
@@ -1,7 +1,7 @@
 #### Note: this error code is no longer emitted by the compiler.
 
-When using generators (or async) all type variables must be bound so a
-generator can be constructed.
+When using coroutines (or async) all type variables must be bound so a
+coroutine can be constructed.
 
 Erroneous code example:
 
@@ -15,7 +15,7 @@ async fn foo() {
 
 In the above example `T` is unknowable by the compiler.
 To fix this you must bind `T` to a concrete type such as `String`
-so that a generator can then be constructed:
+so that a coroutine can then be constructed:
 
 ```edition2018
 async fn bar<T>() -> () {}
diff --git a/compiler/rustc_error_codes/src/error_codes/E0727.md b/compiler/rustc_error_codes/src/error_codes/E0727.md
index 386daea0c57..fde35885c92 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0727.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0727.md
@@ -3,10 +3,10 @@ A `yield` clause was used in an `async` context.
 Erroneous code example:
 
 ```compile_fail,E0727,edition2018
-#![feature(generators)]
+#![feature(coroutines)]
 
 fn main() {
-    let generator = || {
+    let coroutine = || {
         async {
             yield;
         }
@@ -20,10 +20,10 @@ which is not yet supported.
 To fix this error, you have to move `yield` out of the `async` block:
 
 ```edition2018
-#![feature(generators)]
+#![feature(coroutines)]
 
 fn main() {
-    let generator = || {
+    let coroutine = || {
         yield;
     };
 }
diff --git a/compiler/rustc_error_codes/src/error_codes/E0790.md b/compiler/rustc_error_codes/src/error_codes/E0790.md
index 2aee9dfbdbd..b52543c48d8 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0790.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0790.md
@@ -4,24 +4,24 @@ method.
 Erroneous code example:
 
 ```compile_fail,E0790
-trait Generator {
+trait Coroutine {
     fn create() -> u32;
 }
 
 struct Impl;
 
-impl Generator for Impl {
+impl Coroutine for Impl {
     fn create() -> u32 { 1 }
 }
 
 struct AnotherImpl;
 
-impl Generator for AnotherImpl {
+impl Coroutine for AnotherImpl {
     fn create() -> u32 { 2 }
 }
 
-let cont: u32 = Generator::create();
-// error, impossible to choose one of Generator trait implementation
+let cont: u32 = Coroutine::create();
+// error, impossible to choose one of Coroutine trait implementation
 // Should it be Impl or AnotherImpl, maybe something else?
 ```
 
@@ -30,18 +30,18 @@ information to the compiler. In this case, the solution is to use a concrete
 type:
 
 ```
-trait Generator {
+trait Coroutine {
     fn create() -> u32;
 }
 
 struct AnotherImpl;
 
-impl Generator for AnotherImpl {
+impl Coroutine for AnotherImpl {
     fn create() -> u32 { 2 }
 }
 
 let gen1 = AnotherImpl::create();
 
 // if there are multiple methods with same name (different traits)
-let gen2 = <AnotherImpl as Generator>::create();
+let gen2 = <AnotherImpl as Coroutine>::create();
 ```