Remove the CoroutineWitness type

compiler/rustc_borrowck/src/lib.rs

@@ -1801,7 +1801,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
-                    | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::Tuple(_)
                     | ty::UnsafeBinder(_)
@@ -1844,7 +1843,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
-                    | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::UnsafeBinder(_)
                     | ty::Alias(_, _)

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -86,7 +86,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         // them with fresh ty vars.
                         resume_ty: next_ty_var(),
                         yield_ty: next_ty_var(),
-                        witness: next_ty_var(),
                     },
                 )
                 .args,

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -973,19 +973,6 @@ pub(crate) fn assert_assignable<'tcx>(
                 }
             }
         }
-        (&ty::CoroutineWitness(def_id_a, args_a), &ty::CoroutineWitness(def_id_b, args_b))
-            if def_id_a == def_id_b =>
-        {
-            let mut types_a = args_a.types();
-            let mut types_b = args_b.types();
-            loop {
-                match (types_a.next(), types_b.next()) {
-                    (Some(a), Some(b)) => assert_assignable(fx, a, b, limit - 1),
-                    (None, None) => return,
-                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
-                }
-            }
-        }
         _ => {
             assert_eq!(
                 from_ty,

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -344,7 +344,6 @@ fn exported_generic_symbols_provider_local<'tcx>(
                 ty::FnDef(def_id, _) => *def_id,
                 ty::Coroutine(def_id, _) => *def_id,
                 ty::CoroutineClosure(def_id, _) => *def_id,
-                ty::CoroutineWitness(def_id, _) => *def_id,
                 _ => return false,
             };
             let Some(root_def_id) = root_def_id.as_local() else {

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -437,8 +437,7 @@ fn push_debuginfo_type_name<'tcx>(
         | ty::Infer(_)
         | ty::Placeholder(..)
         | ty::Alias(..)
-        | ty::Bound(..)
-        | ty::CoroutineWitness(..) => {
+        | ty::Bound(..) => {
             bug!(
                 "debuginfo: Trying to create type name for \
                   unexpected type: {:?}",

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -176,7 +176,6 @@ fn const_to_valtree_inner<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::CoroutineWitness(..)
         | ty::UnsafeBinder(_) => Err(ValTreeCreationError::NonSupportedType(ty)),
     }
 }
@@ -336,7 +335,6 @@ pub fn valtree_to_const_value<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::CoroutineWitness(..)
         | ty::FnPtr(..)
         | ty::Str
         | ty::Slice(_)

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -184,7 +184,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
-                    | ty::CoroutineWitness(..)
                     | ty::UnsafeBinder(_)
                     | ty::Never
                     | ty::Tuple(_)

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -499,7 +499,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Char
                 | ty::Ref(..)
                 | ty::Coroutine(..)
-                | ty::CoroutineWitness(..)
                 | ty::Array(..)
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -795,8 +795,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
             | ty::Placeholder(..)
             | ty::Bound(..)
             | ty::Param(..)
-            | ty::Alias(..)
-            | ty::CoroutineWitness(..) => bug!("Encountered invalid type {:?}", ty),
+            | ty::Alias(..) => bug!("Encountered invalid type {:?}", ty),
         }
     }
 

compiler/rustc_const_eval/src/util/type_name.rs

@@ -58,7 +58,6 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
 
             ty::Alias(ty::Free, _) => bug!("type_name: unexpected free alias"),
             ty::Alias(ty::Inherent, _) => bug!("type_name: unexpected inherent projection"),
-            ty::CoroutineWitness(..) => bug!("type_name: unexpected `CoroutineWitness`"),
         }
     }
 

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -194,7 +194,6 @@ impl<'tcx> InherentCollect<'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
             | ty::Alias(ty::Free, _)
             | ty::Bound(..)
             | ty::Placeholder(_)

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -230,7 +230,6 @@ pub(crate) fn orphan_check_impl(
             ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
             | ty::Bound(..)
             | ty::Placeholder(..)
             | ty::Infer(..) => {

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -379,20 +379,14 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         // for info on the usage of each of these fields.
         let dummy_args = match kind {
             ClosureKind::Closure => &["<closure_kind>", "<closure_signature>", "<upvars>"][..],
-            ClosureKind::Coroutine(_) => &[
-                "<coroutine_kind>",
-                "<resume_ty>",
-                "<yield_ty>",
-                "<return_ty>",
-                "<witness>",
-                "<upvars>",
-            ][..],
+            ClosureKind::Coroutine(_) => {
+                &["<coroutine_kind>", "<resume_ty>", "<yield_ty>", "<return_ty>", "<upvars>"][..]
+            }
             ClosureKind::CoroutineClosure(_) => &[
                 "<closure_kind>",
                 "<closure_signature_parts>",
                 "<upvars>",
                 "<bound_captures_by_ref>",
-                "<witness>",
             ][..],
         };
 

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -323,7 +323,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 // types, where we use Error as the Self type
             }
 
-            ty::Placeholder(..) | ty::CoroutineWitness(..) | ty::Bound(..) | ty::Infer(..) => {
+            ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) => {
                 bug!("unexpected type encountered in variance inference: {}", ty);
             }
         }

compiler/rustc_hir_typeck/src/cast.rs

@@ -132,7 +132,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             | ty::Uint(..)
             | ty::Float(_)
             | ty::Array(..)
-            | ty::CoroutineWitness(..)
             | ty::RawPtr(_, _)
             | ty::Ref(..)
             | ty::Pat(..)

compiler/rustc_hir_typeck/src/closure.rs

@@ -161,8 +161,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Resume type defaults to `()` if the coroutine has no argument.
                 let resume_ty = liberated_sig.inputs().get(0).copied().unwrap_or(tcx.types.unit);
 
-                let interior = Ty::new_coroutine_witness(tcx, expr_def_id.to_def_id(), parent_args);
-
                 // Coroutines that come from coroutine closures have not yet determined
                 // their kind ty, so make a fresh infer var which will be constrained
                 // later during upvar analysis. Regular coroutines always have the kind
@@ -182,7 +180,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         resume_ty,
                         yield_ty,
                         return_ty: liberated_sig.output(),
-                        witness: interior,
                         tupled_upvars_ty,
                     },
                 );
@@ -210,7 +207,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 };
                 // Compute all of the variables that will be used to populate the coroutine.
                 let resume_ty = self.next_ty_var(expr_span);
-                let interior = self.next_ty_var(expr_span);
 
                 let closure_kind_ty = match expected_kind {
                     Some(kind) => Ty::from_closure_kind(tcx, kind),
@@ -243,7 +239,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         ),
                         tupled_upvars_ty,
                         coroutine_captures_by_ref_ty,
-                        coroutine_witness_ty: interior,
                     },
                 );
 

compiler/rustc_hir_typeck/src/coercion.rs

@@ -562,7 +562,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
-            | ty::CoroutineWitness(_, _)
             | ty::Never
             | ty::Tuple(_) => return Err(TypeError::Mismatch),
             _ => {}

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -408,7 +408,6 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
             | ty::Bool
             | ty::Char
             | ty::Int(..)

compiler/rustc_lint/src/foreign_modules.rs

@@ -368,7 +368,6 @@ fn structurally_same_type_impl<'tcx>(
                 | (ty::Error(..), ty::Error(..))
                 | (ty::Closure(..), ty::Closure(..))
                 | (ty::Coroutine(..), ty::Coroutine(..))
-                | (ty::CoroutineWitness(..), ty::CoroutineWitness(..))
                 | (ty::Alias(ty::Projection, ..), ty::Alias(ty::Projection, ..))
                 | (ty::Alias(ty::Inherent, ..), ty::Alias(ty::Inherent, ..))
                 | (ty::Alias(ty::Opaque, ..), ty::Alias(ty::Opaque, ..)) => false,

compiler/rustc_lint/src/types.rs

@@ -1407,7 +1407,6 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
             | ty::Placeholder(..)
             | ty::FnDef(..) => bug!("unexpected type in foreign function: {:?}", ty),
         }

compiler/rustc_middle/src/ty/context.rs

@@ -607,11 +607,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             // `assemble_candidates_after_normalizing_self_ty`.
             ty::Alias(_, _) | ty::Placeholder(..) | ty::Error(_) => (),
 
-            // FIXME: These should ideally not exist as a self type. It would be nice for
-            // the builtin auto trait impls of coroutines to instead directly recurse
-            // into the witness.
-            ty::CoroutineWitness(..) => (),
-
             // These variants should not exist as a self type.
             ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_))
             | ty::Param(_)
@@ -2498,7 +2493,6 @@ impl<'tcx> TyCtxt<'tcx> {
                 UnsafeBinder,
                 Placeholder,
                 Coroutine,
-                CoroutineWitness,
                 Dynamic,
                 Closure,
                 CoroutineClosure,

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -608,7 +608,6 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for IsSuggestableVisitor<'tcx> {
             | Closure(..)
             | Infer(..)
             | Coroutine(..)
-            | CoroutineWitness(..)
             | Bound(_, _)
             | Placeholder(_)
             | Error(_) => {
@@ -692,7 +691,6 @@ impl<'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for MakeSuggestableFolder<'tcx> {
             | FnDef(..)
             | Infer(..)
             | Coroutine(..)
-            | CoroutineWitness(..)
             | Bound(_, _)
             | Placeholder(_)
             | Error(_) => {

compiler/rustc_middle/src/ty/error.rs

@@ -138,7 +138,6 @@ impl<'tcx> Ty<'tcx> {
             ty::Coroutine(def_id, ..) => {
                 format!("{:#}", tcx.coroutine_kind(def_id).unwrap()).into()
             }
-            ty::CoroutineWitness(..) => "coroutine witness".into(),
             ty::Infer(ty::TyVar(_)) => "inferred type".into(),
             ty::Infer(ty::IntVar(_)) => "integer".into(),
             ty::Infer(ty::FloatVar(_)) => "floating-point number".into(),
@@ -200,7 +199,6 @@ impl<'tcx> Ty<'tcx> {
             ty::Coroutine(def_id, ..) => {
                 format!("{:#}", tcx.coroutine_kind(def_id).unwrap()).into()
             }
-            ty::CoroutineWitness(..) => "coroutine witness".into(),
             ty::Tuple(..) => "tuple".into(),
             ty::Placeholder(..) => "higher-ranked type".into(),
             ty::Bound(..) => "bound type variable".into(),

compiler/rustc_middle/src/ty/generic_args.rs

@@ -96,38 +96,29 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
                 signature_parts_ty,
                 tupled_upvars_ty,
                 coroutine_captures_by_ref_ty,
-                coroutine_witness_ty,
             ] => ty::CoroutineClosureArgsParts {
                 parent_args,
                 closure_kind_ty: closure_kind_ty.expect_ty(),
                 signature_parts_ty: signature_parts_ty.expect_ty(),
                 tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
                 coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(),
-                coroutine_witness_ty: coroutine_witness_ty.expect_ty(),
             },
             _ => bug!("closure args missing synthetics"),
         }
     }
 
     fn split_coroutine_args(self) -> ty::CoroutineArgsParts<TyCtxt<'tcx>> {
         match self[..] {
-            [
-                ref parent_args @ ..,
-                kind_ty,
-                resume_ty,
-                yield_ty,
-                return_ty,
-                witness,
-                tupled_upvars_ty,
-            ] => ty::CoroutineArgsParts {
-                parent_args,
-                kind_ty: kind_ty.expect_ty(),
-                resume_ty: resume_ty.expect_ty(),
-                yield_ty: yield_ty.expect_ty(),
-                return_ty: return_ty.expect_ty(),
-                witness: witness.expect_ty(),
-                tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
-            },
+            [ref parent_args @ .., kind_ty, resume_ty, yield_ty, return_ty, tupled_upvars_ty] => {
+                ty::CoroutineArgsParts {
+                    parent_args,
+                    kind_ty: kind_ty.expect_ty(),
+                    resume_ty: resume_ty.expect_ty(),
+                    yield_ty: yield_ty.expect_ty(),
+                    return_ty: return_ty.expect_ty(),
+                    tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
+                }
+            }
             _ => bug!("coroutine args missing synthetics"),
         }
     }

compiler/rustc_middle/src/ty/layout.rs

@@ -806,7 +806,6 @@ where
                 | ty::FnPtr(..)
                 | ty::Never
                 | ty::FnDef(..)
-                | ty::CoroutineWitness(..)
                 | ty::Foreign(..)
                 | ty::Pat(_, _)
                 | ty::Dynamic(_, _, ty::Dyn) => {

compiler/rustc_middle/src/ty/opaque_types.rs

@@ -155,11 +155,6 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
                 Ty::new_coroutine(self.tcx, def_id, args)
             }
 
-            ty::CoroutineWitness(def_id, args) => {
-                let args = self.fold_closure_args(def_id, args);
-                Ty::new_coroutine_witness(self.tcx, def_id, args)
-            }
-
             ty::Param(param) => {
                 // Look it up in the generic parameters list.
                 match self.map.get(&ty.into()).map(|arg| arg.kind()) {

compiler/rustc_middle/src/ty/print/mod.rs

@@ -287,7 +287,6 @@ fn characteristic_def_id_of_type_cached<'a>(
         | ty::Closure(def_id, _)
         | ty::CoroutineClosure(def_id, _)
         | ty::Coroutine(def_id, _)
-        | ty::CoroutineWitness(def_id, _)
         | ty::Foreign(def_id) => Some(def_id),
 
         ty::Bool