Movability doesn't need to be a query anymore

Author: compiler-errors

compiler/rustc_borrowck/src/lib.rs

@@ -275,7 +275,7 @@ fn do_mir_borrowck<'tcx>(
         if let Some(local) = body.local_decls.raw.get(1)
         // Get the interior types and args which typeck computed
         && let ty::Coroutine(def_id, _) = *local.ty.kind()
-        && tcx.movability(def_id) == hir::Movability::Movable
+        && tcx.coroutine_kind(def_id).unwrap().movability() == hir::Movability::Movable
     {
         true
     } else {

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -240,7 +240,6 @@ provide! { tcx, def_id, other, cdata,
     mir_const_qualif => { table }
     rendered_const => { table }
     asyncness => { table_direct }
-    movability => { table_direct }
     fn_arg_names => { table }
     coroutine_kind => { table_direct }
     trait_def => { table }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1432,8 +1432,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if def_kind == DefKind::Closure
                 && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id)
             {
-                self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind));
-                self.tables.movability.set(def_id.index, Some(self.tcx.movability(def_id)));
+                self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind))
             }
             if let DefKind::Enum | DefKind::Struct | DefKind::Union = def_kind {
                 self.encode_info_for_adt(local_id);

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -447,7 +447,6 @@ define_tables! {
     mir_const_qualif: Table<DefIndex, LazyValue<mir::ConstQualifs>>,
     rendered_const: Table<DefIndex, LazyValue<String>>,
     asyncness: Table<DefIndex, ty::Asyncness>,
-    movability: Table<DefIndex, hir::Movability>,
     fn_arg_names: Table<DefIndex, LazyArray<Ident>>,
     coroutine_kind: Table<DefIndex, hir::CoroutineKind>,
     trait_def: Table<DefIndex, LazyValue<ty::TraitDef>>,

compiler/rustc_middle/src/mir/pretty.rs

@@ -1308,7 +1308,7 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
                     self.push("coroutine");
                     self.push(&format!("+ def_id: {def_id:?}"));
                     self.push(&format!("+ args: {args:#?}"));
-                    self.push(&format!("+ movability: {:?}", self.tcx.movability(def_id)));
+                    self.push(&format!("+ kind: {:?}", self.tcx.coroutine_kind(def_id)));
                 }
 
                 AggregateKind::Adt(_, _, _, Some(user_ty), _) => {

compiler/rustc_middle/src/query/mod.rs

@@ -721,11 +721,6 @@ rustc_queries! {
         desc { |tcx| "computing drop-check constraints for `{}`", tcx.def_path_str(key) }
     }
 
-    query movability(key: DefId) -> hir::Movability {
-        desc { |tcx| "checking if coroutine is movable: `{}`", tcx.def_path_str(key) }
-        separate_provide_extern
-    }
-
     /// Returns `true` if this is a const fn, use the `is_const_fn` to know whether your crate
     /// actually sees it as const fn (e.g., the const-fn-ness might be unstable and you might
     /// not have the feature gate active).

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

@@ -790,7 +790,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     || matches!(coroutine_kind, hir::CoroutineKind::Coroutine(_));
 
                 if should_print_movability {
-                    match self.tcx().movability(did) {
+                    match coroutine_kind.movability() {
                         hir::Movability::Movable => {}
                         hir::Movability::Static => p!("static "),
                     }

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -552,9 +552,11 @@ impl<'tcx> Cx<'tcx> {
                 let closure_ty = self.typeck_results().expr_ty(expr);
                 let (def_id, args, movability) = match *closure_ty.kind() {
                     ty::Closure(def_id, args) => (def_id, UpvarArgs::Closure(args), None),
-                    ty::Coroutine(def_id, args) => {
-                        (def_id, UpvarArgs::Coroutine(args), Some(tcx.movability(def_id)))
-                    }
+                    ty::Coroutine(def_id, args) => (
+                        def_id,
+                        UpvarArgs::Coroutine(args),
+                        Some(tcx.coroutine_kind(def_id).unwrap().movability()),
+                    ),
                     _ => {
                         span_bug!(expr.span, "closure expr w/o closure type: {:?}", closure_ty);
                     }

compiler/rustc_mir_transform/src/coroutine.rs

@@ -1565,7 +1565,9 @@ pub(crate) fn mir_coroutine_witnesses<'tcx>(
     let coroutine_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty;
 
     let movable = match *coroutine_ty.kind() {
-        ty::Coroutine(def_id, _) => tcx.movability(def_id) == hir::Movability::Movable,
+        ty::Coroutine(def_id, _) => {
+            tcx.coroutine_kind(def_id).unwrap().movability() == hir::Movability::Movable
+        }
         ty::Error(_) => return None,
         _ => span_bug!(body.span, "unexpected coroutine type {}", coroutine_ty),
     };
@@ -1597,12 +1599,13 @@ impl<'tcx> MirPass<'tcx> for StateTransform {
 
         // The first argument is the coroutine type passed by value
         let coroutine_ty = body.local_decls.raw[1].ty;
+        let coroutine_kind = body.coroutine_kind().unwrap();
 
         // Get the discriminant type and args which typeck computed
         let (discr_ty, movable) = match *coroutine_ty.kind() {
-            ty::Coroutine(def_id, args) => {
+            ty::Coroutine(_, args) => {
                 let args = args.as_coroutine();
-                (args.discr_ty(tcx), tcx.movability(def_id) == hir::Movability::Movable)
+                (args.discr_ty(tcx), coroutine_kind.movability() == hir::Movability::Movable)
             }
             _ => {
                 tcx.dcx().span_delayed_bug(
@@ -1613,19 +1616,13 @@ impl<'tcx> MirPass<'tcx> for StateTransform {
             }
         };
 
-        let is_async_kind = matches!(
-            body.coroutine_kind(),
-            Some(CoroutineKind::Desugared(CoroutineDesugaring::Async, _))
-        );
-        let is_async_gen_kind = matches!(
-            body.coroutine_kind(),
-            Some(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _))
-        );
-        let is_gen_kind = matches!(
-            body.coroutine_kind(),
-            Some(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _))
-        );
-        let new_ret_ty = match body.coroutine_kind().unwrap() {
+        let is_async_kind =
+            matches!(coroutine_kind, CoroutineKind::Desugared(CoroutineDesugaring::Async, _));
+        let is_async_gen_kind =
+            matches!(coroutine_kind, CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _));
+        let is_gen_kind =
+            matches!(coroutine_kind, CoroutineKind::Desugared(CoroutineDesugaring::Gen, _));
+        let new_ret_ty = match coroutine_kind {
             CoroutineKind::Desugared(CoroutineDesugaring::Async, _) => {
                 // Compute Poll<return_ty>
                 let poll_did = tcx.require_lang_item(LangItem::Poll, None);

compiler/rustc_mir_transform/src/shim.rs

@@ -395,7 +395,10 @@ fn build_clone_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -
         ty::Closure(_, args) => builder.tuple_like_shim(dest, src, args.as_closure().upvar_tys()),
         ty::Tuple(..) => builder.tuple_like_shim(dest, src, self_ty.tuple_fields()),
         ty::Coroutine(coroutine_def_id, args) => {
-            assert_eq!(tcx.movability(coroutine_def_id), hir::Movability::Movable);
+            assert_eq!(
+                tcx.coroutine_kind(coroutine_def_id).unwrap().movability(),
+                hir::Movability::Movable
+            );
             builder.coroutine_shim(dest, src, *coroutine_def_id, args.as_coroutine())
         }
         _ => bug!("clone shim for `{:?}` which is not `Copy` and is not an aggregate", self_ty),