Add hir::GeneratorKind::Iter

oli-obk · oli-obk · commit 1f46790ff4d2 · 2023-10-20T23:56:10.000Z
This is a placeholder name until we change `Gen` to `Coroutine`.
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -712,7 +712,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let full_span = expr.span.to(await_kw_span);
         match self.coroutine_kind {
             Some(hir::CoroutineKind::Async(_)) => {}
-            Some(hir::CoroutineKind::Coroutine) | None => {
+            Some(hir::CoroutineKind::Coroutine) | Some(hir::CoroutineKind::Gen(_)) | None => {
                 self.tcx.sess.emit_err(AwaitOnlyInAsyncFnAndBlocks {
                     await_kw_span,
                     item_span: self.current_item,
@@ -930,7 +930,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         movability: Movability,
     ) -> Option<hir::Movability> {
         match coroutine_kind {
-            Some(hir::CoroutineKind::Coroutine) => {
+            Some(hir::CoroutineKind::Gen(_)) | Some(hir::CoroutineKind::Coroutine) => {
                 if decl.inputs.len() > 1 {
                     self.tcx.sess.emit_err(CoroutineTooManyParameters { fn_decl_span });
                 }
@@ -1446,6 +1446,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_expr_yield(&mut self, span: Span, opt_expr: Option<&Expr>) -> hir::ExprKind<'hir> {
         match self.coroutine_kind {
             Some(hir::CoroutineKind::Coroutine) => {}
+            Some(hir::CoroutineKind::Gen(_)) => {}
             Some(hir::CoroutineKind::Async(_)) => {
                 self.tcx.sess.emit_err(AsyncCoroutinesNotSupported { span });
             }
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -2483,6 +2483,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         };
         let kind = match use_span.coroutine_kind() {
             Some(coroutine_kind) => match coroutine_kind {
+                CoroutineKind::Gen(kind) => match kind {
+                    AsyncCoroutineKind::Block => "gen block",
+                    AsyncCoroutineKind::Closure => "gen closure",
+                    _ => bug!("gen block/closure expected, but gen function found."),
+                },
                 CoroutineKind::Async(async_kind) => match async_kind {
                     AsyncCoroutineKind::Block => "async block",
                     AsyncCoroutineKind::Closure => "async closure",
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -698,6 +698,20 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                             " of async function"
                         }
                     },
+                    Some(hir::CoroutineKind::Gen(gen)) => match gen {
+                        hir::AsyncCoroutineKind::Block => " of gen block",
+                        hir::AsyncCoroutineKind::Closure => " of gen closure",
+                        hir::AsyncCoroutineKind::Fn => {
+                            let parent_item =
+                                hir.get_by_def_id(hir.get_parent_item(mir_hir_id).def_id);
+                            let output = &parent_item
+                                .fn_decl()
+                                .expect("generator lowered from gen fn should be in fn")
+                                .output;
+                            span = output.span();
+                            " of gen function"
+                        }
+                    },
                     Some(hir::CoroutineKind::Coroutine) => " of coroutine",
                     None => " of closure",
                 };
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -560,6 +560,9 @@ pub fn push_item_name(tcx: TyCtxt<'_>, def_id: DefId, qualified: bool, output: &
 
 fn coroutine_kind_label(coroutine_kind: Option<CoroutineKind>) -> &'static str {
     match coroutine_kind {
+        Some(CoroutineKind::Gen(AsyncCoroutineKind::Block)) => "gen_block",
+        Some(CoroutineKind::Gen(AsyncCoroutineKind::Closure)) => "gen_closure",
+        Some(CoroutineKind::Gen(AsyncCoroutineKind::Fn)) => "gen_fn",
         Some(CoroutineKind::Async(AsyncCoroutineKind::Block)) => "async_block",
         Some(CoroutineKind::Async(AsyncCoroutineKind::Closure)) => "async_closure",
         Some(CoroutineKind::Async(AsyncCoroutineKind::Fn)) => "async_fn",
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -1513,6 +1513,9 @@ pub enum CoroutineKind {
     /// An explicit `async` block or the body of an async function.
     Async(AsyncCoroutineKind),
 
+    /// An explicit `gen` block or the body of a `gen`` function.
+    Gen(AsyncCoroutineKind),
+
     /// A coroutine literal created via a `yield` inside a closure.
     Coroutine,
 }
@@ -1522,6 +1525,8 @@ impl fmt::Display for CoroutineKind {
         match self {
             CoroutineKind::Async(k) => fmt::Display::fmt(k, f),
             CoroutineKind::Coroutine => f.write_str("coroutine"),
+            // FIXME(oli-obk): this should print `gen fn`, not `async fn`
+            CoroutineKind::Gen(k) => fmt::Display::fmt(k, f),
         }
     }
 }
@@ -1531,6 +1536,8 @@ impl CoroutineKind {
         match self {
             CoroutineKind::Async(ask) => ask.descr(),
             CoroutineKind::Coroutine => "coroutine",
+            // FIXME(oli-obk): this should print `gen fn`, not `async fn`
+            CoroutineKind::Gen(ask) => ask.descr(),
         }
     }
 }
@@ -2253,6 +2260,7 @@ impl From<CoroutineKind> for YieldSource {
             // Guess based on the kind of the current coroutine.
             CoroutineKind::Coroutine => Self::Yield,
             CoroutineKind::Async(_) => Self::Await { expr: None },
+            CoroutineKind::Gen(_) => Self::Yield,
         }
     }
 }
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
@@ -141,8 +141,14 @@ impl<O> AssertKind<O> {
             RemainderByZero(_) => "attempt to calculate the remainder with a divisor of zero",
             ResumedAfterReturn(CoroutineKind::Coroutine) => "coroutine resumed after completion",
             ResumedAfterReturn(CoroutineKind::Async(_)) => "`async fn` resumed after completion",
+            ResumedAfterReturn(CoroutineKind::Gen(_)) => {
+                bug!("`gen fn` should just keep returning `None` after the first time")
+            }
             ResumedAfterPanic(CoroutineKind::Coroutine) => "coroutine resumed after panicking",
             ResumedAfterPanic(CoroutineKind::Async(_)) => "`async fn` resumed after panicking",
+            ResumedAfterPanic(CoroutineKind::Gen(_)) => {
+                bug!("`gen fn` should just keep returning `None` after panicking")
+            }
             BoundsCheck { .. } | MisalignedPointerDereference { .. } => {
                 bug!("Unexpected AssertKind")
             }
@@ -229,10 +235,14 @@ impl<O> AssertKind<O> {
             DivisionByZero(_) => middle_assert_divide_by_zero,
             RemainderByZero(_) => middle_assert_remainder_by_zero,
             ResumedAfterReturn(CoroutineKind::Async(_)) => middle_assert_async_resume_after_return,
+            // FIXME(oli-obk): custom error message for `gen` blocks
+            ResumedAfterReturn(CoroutineKind::Gen(_)) => middle_assert_async_resume_after_return,
             ResumedAfterReturn(CoroutineKind::Coroutine) => {
                 middle_assert_coroutine_resume_after_return
             }
             ResumedAfterPanic(CoroutineKind::Async(_)) => middle_assert_async_resume_after_panic,
+            // FIXME(oli-obk): custom error message for `gen` blocks
+            ResumedAfterPanic(CoroutineKind::Gen(_)) => middle_assert_async_resume_after_panic,
             ResumedAfterPanic(CoroutineKind::Coroutine) => {
                 middle_assert_coroutine_resume_after_panic
             }
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
@@ -749,6 +749,7 @@ impl<'tcx> TyCtxt<'tcx> {
             DefKind::Coroutine => match self.coroutine_kind(def_id).unwrap() {
                 rustc_hir::CoroutineKind::Async(..) => "async closure",
                 rustc_hir::CoroutineKind::Coroutine => "coroutine",
+                rustc_hir::CoroutineKind::Gen(..) => "gen closure",
             },
             _ => def_kind.descr(def_id),
         }
@@ -766,6 +767,7 @@ impl<'tcx> TyCtxt<'tcx> {
             DefKind::Coroutine => match self.coroutine_kind(def_id).unwrap() {
                 rustc_hir::CoroutineKind::Async(..) => "an",
                 rustc_hir::CoroutineKind::Coroutine => "a",
+                rustc_hir::CoroutineKind::Gen(..) => "a",
             },
             _ => def_kind.article(),
         }
diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -873,6 +873,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {
                 };
                 stable_mir::mir::CoroutineKind::Async(async_gen)
             }
+            CoroutineKind::Gen(..) => stable_mir::mir::CoroutineKind::Coroutine,
             CoroutineKind::Coroutine => stable_mir::mir::CoroutineKind::Coroutine,
         }
     }
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -2425,6 +2425,21 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                         CoroutineKind::Async(AsyncCoroutineKind::Closure) => {
                             format!("future created by async closure is not {trait_name}")
                         }
+                        CoroutineKind::Gen(AsyncCoroutineKind::Fn) => self
+                            .tcx
+                            .parent(coroutine_did)
+                            .as_local()
+                            .map(|parent_did| hir.local_def_id_to_hir_id(parent_did))
+                            .and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
+                            .map(|name| {
+                                format!("iterator returned by `{name}` is not {trait_name}")
+                            })?,
+                        CoroutineKind::Gen(AsyncCoroutineKind::Block) => {
+                            format!("iterator created by async block is not {trait_name}")
+                        }
+                        CoroutineKind::Gen(AsyncCoroutineKind::Closure) => {
+                            format!("iterator created by async closure is not {trait_name}")
+                        }
                     })
                 })
                 .unwrap_or_else(|| format!("{future_or_coroutine} is not {trait_name}"));
@@ -2882,7 +2897,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
             }
             ObligationCauseCode::SizedCoroutineInterior(coroutine_def_id) => {
                 let what = match self.tcx.coroutine_kind(coroutine_def_id) {
-                    None | Some(hir::CoroutineKind::Coroutine) => "yield",
+                    None | Some(hir::CoroutineKind::Coroutine) | Some(hir::CoroutineKind::Gen(_)) => "yield",
                     Some(hir::CoroutineKind::Async(..)) => "await",
                 };
                 err.note(format!(
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
@@ -1619,6 +1619,9 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
             hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Block) => "an async block",
             hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Fn) => "an async function",
             hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Closure) => "an async closure",
+            hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Block) => "a gen block",
+            hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Fn) => "a gen function",
+            hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Closure) => "a gen closure",
         })
     }
 
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
@@ -135,6 +135,7 @@ pub enum UnOp {
 pub enum CoroutineKind {
     Async(AsyncCoroutineKind),
     Coroutine,
+    Gen(AsyncCoroutineKind),
 }
 
 #[derive(Clone, Debug)]

Original file line number	Diff line number	Diff line change
`@@ -1513,6 +1513,9 @@ pub enum CoroutineKind {`
`1513`	`1513`	/// An explicit `async` block or the body of an async function.
`1514`	`1514`	`Async(AsyncCoroutineKind),`
`1515`	`1515`
	`1516`	+ /// An explicit `gen` block or the body of a `gen`` function.
	`1517`	`+ Gen(AsyncCoroutineKind),`
	`1518`	`+`
`1516`	`1519`	/// A coroutine literal created via a `yield` inside a closure.
`1517`	`1520`	`Coroutine,`
`1518`	`1521`	`}`
`@@ -1522,6 +1525,8 @@ impl fmt::Display for CoroutineKind {`
`1522`	`1525`	`match self {`
`1523`	`1526`	`CoroutineKind::Async(k) => fmt::Display::fmt(k, f),`
`1524`	`1527`	`CoroutineKind::Coroutine => f.write_str("coroutine"),`
	`1528`	+ // FIXME(oli-obk): this should print `gen fn`, not `async fn`
	`1529`	`+ CoroutineKind::Gen(k) => fmt::Display::fmt(k, f),`
`1525`	`1530`	`}`
`1526`	`1531`	`}`
`1527`	`1532`	`}`
`@@ -1531,6 +1536,8 @@ impl CoroutineKind {`
`1531`	`1536`	`match self {`
`1532`	`1537`	`CoroutineKind::Async(ask) => ask.descr(),`
`1533`	`1538`	`CoroutineKind::Coroutine => "coroutine",`
	`1539`	+ // FIXME(oli-obk): this should print `gen fn`, not `async fn`
	`1540`	`+ CoroutineKind::Gen(ask) => ask.descr(),`
`1534`	`1541`	`}`
`1535`	`1542`	`}`
`1536`	`1543`	`}`
`@@ -2253,6 +2260,7 @@ impl From<CoroutineKind> for YieldSource {`
`2253`	`2260`	`// Guess based on the kind of the current coroutine.`
`2254`	`2261`	`CoroutineKind::Coroutine => Self::Yield,`
`2255`	`2262`	`CoroutineKind::Async(_) => Self::Await { expr: None },`
	`2263`	`+ CoroutineKind::Gen(_) => Self::Yield,`
`2256`	`2264`	`}`
`2257`	`2265`	`}`
`2258`	`2266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -873,6 +873,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {`
`873`	`873`	`};`
`874`	`874`	`stable_mir::mir::CoroutineKind::Async(async_gen)`
`875`	`875`	`}`
	`876`	`+ CoroutineKind::Gen(..) => stable_mir::mir::CoroutineKind::Coroutine,`
`876`	`877`	`CoroutineKind::Coroutine => stable_mir::mir::CoroutineKind::Coroutine,`
`877`	`878`	`}`
`878`	`879`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1619,6 +1619,9 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {`
`1619`	`1619`	`hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Block) => "an async block",`
`1620`	`1620`	`hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Fn) => "an async function",`
`1621`	`1621`	`hir::CoroutineKind::Async(hir::AsyncCoroutineKind::Closure) => "an async closure",`
	`1622`	`+ hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Block) => "a gen block",`
	`1623`	`+ hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Fn) => "a gen function",`
	`1624`	`+ hir::CoroutineKind::Gen(hir::AsyncCoroutineKind::Closure) => "a gen closure",`
`1622`	`1625`	`})`
`1623`	`1626`	`}`
`1624`	`1627`
Original file line number	Diff line number	Diff line change
`@@ -135,6 +135,7 @@ pub enum UnOp {`
`135`	`135`	`pub enum CoroutineKind {`
`136`	`136`	`Async(AsyncCoroutineKind),`
`137`	`137`	`Coroutine,`
	`138`	`+ Gen(AsyncCoroutineKind),`
`138`	`139`	`}`
`139`	`140`
`140`	`141`	`#[derive(Clone, Debug)]`