Gate const coroutines better

Author: eholk

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -589,13 +589,23 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
             Rvalue::Aggregate(kind, ..) => {
                 if let AggregateKind::Coroutine(def_id, ..) = kind.as_ref()
-                    && let Some(
-                        coroutine_kind @ hir::CoroutineKind::Desugared(
-                            hir::CoroutineDesugaring::Async | hir::CoroutineDesugaring::Gen,
-                            _,
-                        ),
-                    ) = self.tcx.coroutine_kind(def_id)
+                    && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id)
                 {
+                    // match coroutine_kind {
+                    //     CoroutineKind::Desugared(
+                    //         CoroutineDesugaring::Async
+                    //         | CoroutineDesugaring::Gen
+                    //         | CoroutineDesugaring::AsyncGen,
+                    //         _,
+                    //     ) => {
+                    //         self.check_op(ops::Coroutine(coroutine_kind));
+                    //     }
+                    //     CoroutineKind::Coroutine(_) => {
+                    //         // This is a generator witness, which is not a coroutine.
+                    //         // We don't need to check it.
+                    //     }
+                    // }
+
                     self.check_op(ops::Coroutine(coroutine_kind));
                 }
             }

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -486,19 +486,18 @@ impl<'tcx> NonConstOp<'tcx> for IntrinsicUnstable {
 pub(crate) struct Coroutine(pub hir::CoroutineKind);
 impl<'tcx> NonConstOp<'tcx> for Coroutine {
     fn status_in_item(&self, _: &ConstCx<'_, 'tcx>) -> Status {
-        if let hir::CoroutineKind::Desugared(
-            hir::CoroutineDesugaring::Async,
-            hir::CoroutineSource::Block,
-        ) = self.0
-        {
-            Status::Unstable {
+        match self.0 {
+            hir::CoroutineKind::Desugared(
+                hir::CoroutineDesugaring::Async,
+                hir::CoroutineSource::Block,
+            )
+            | hir::CoroutineKind::Coroutine(_) => Status::Unstable {
                 gate: sym::const_async_blocks,
                 gate_already_checked: false,
                 safe_to_expose_on_stable: false,
                 is_function_call: false,
-            }
-        } else {
-            Status::Forbidden
+            },
+            _ => Status::Forbidden,
         }
     }
 

tests/ui/coroutine/const_gen_fn.rs

@@ -8,5 +8,6 @@ const gen fn a() {}
 
 const async gen fn b() {}
 //~^ ERROR functions cannot be both `const` and `async gen`
+//~^^ ERROR `async gen` fn bodies are not allowed in constant functions
 
 fn main() {}

tests/ui/coroutine/const_gen_fn.stderr

@@ -22,5 +22,11 @@ error: `gen` fn bodies are not allowed in constant functions
 LL | const gen fn a() {}
    |                  ^^
 
-error: aborting due to 3 previous errors
+error: `async gen` fn bodies are not allowed in constant functions
+  --> $DIR/const_gen_fn.rs:9:24
+   |
+LL | const async gen fn b() {}
+   |                        ^^
+
+error: aborting due to 4 previous errors
 

tests/ui/suggestions/unnamable-types.rs

@@ -1,7 +1,7 @@
 // Test that we do not suggest to add type annotations for unnamable types.
 
 #![crate_type="lib"]
-#![feature(coroutines, stmt_expr_attributes)]
+#![feature(coroutines, stmt_expr_attributes, const_async_blocks)]
 
 const A = 5;
 //~^ ERROR: missing type for `const` item

tests/ui/type-alias-impl-trait/issue-53678-coroutine-and-const-fn.rs

@@ -1,4 +1,4 @@
-#![feature(coroutines, coroutine_trait, rustc_attrs)]
+#![feature(coroutines, coroutine_trait, rustc_attrs, const_async_blocks)]
 #![feature(type_alias_impl_trait)]
 
 //@ check-pass