wip

Author: cjgillot

compiler/rustc_middle/src/query/mod.rs

@@ -2651,11 +2651,11 @@ rustc_queries! {
     }
 
     query generics_require_sized_self(def_id: DefId) -> bool {
-        desc { "check whether the item has a `where Self: Sized` bound" }
+        desc { |tcx| "check whether `{}` has a `where Self: Sized` bound", tcx.def_path_str(def_id) }
     }
 
     query cross_crate_inlinable(def_id: DefId) -> bool {
-        desc { "whether the item should be made inlinable across crates" }
+        desc { |tcx| "whether `{}` should be made inlinable across crates", tcx.def_path_str(def_id) }
         separate_provide_extern
     }
 

compiler/rustc_mir_transform/src/cross_crate_inline.rs

@@ -92,6 +92,11 @@ fn cross_crate_inlinable(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
         InliningThreshold::Never => return false,
     };
 
+    // Avoid inlining coroutines, since that does not make any sense.
+    if tcx.is_coroutine(def_id.to_def_id()) {
+        return false;
+    }
+
     let mir = tcx.optimized_mir(def_id);
     let mut checker =
         CostChecker { tcx, callee_body: mir, calls: 0, statements: 0, landing_pads: 0, resumes: 0 };

compiler/rustc_mir_transform/src/inline.rs

@@ -349,14 +349,7 @@ impl<'tcx> Inliner<'tcx> for NormalInliner<'tcx> {
         }
     }
 
-    fn check_caller_mir_body(&self, body: &Body<'tcx>) -> bool {
-        // Avoid inlining into coroutines, since their `optimized_mir` is used for layout computation,
-        // which can create a cycle, even when no attempt is made to inline the function in the other
-        // direction.
-        if body.coroutine.is_some() {
-            return false;
-        }
-
+    fn check_caller_mir_body(&self, _: &Body<'tcx>) -> bool {
         true
     }
 
@@ -709,6 +702,11 @@ fn check_mir_is_available<'tcx, I: Inliner<'tcx>>(
         return Err("self-recursion");
     }
 
+    // Avoid inlining coroutines, since that does not make any sense.
+    if inliner.tcx().is_coroutine(callee_def_id) {
+        return Err("coroutine");
+    }
+
     match callee.def {
         InstanceKind::Item(_) => {
             // If there is no MIR available (either because it was not in metadata or

compiler/rustc_mir_transform/src/inline/cycle.rs

@@ -94,6 +94,15 @@ fn process<'tcx>(
             continue;
         }
 
+        // Avoid inlining into coroutines, since their `optimized_mir` is used for layout computation,
+        // which can create a cycle, even when no attempt is made to inline the function in the other
+        // direction.
+        if tcx.is_coroutine(callee.def_id()) {
+            reaches_root = true;
+            seen.insert(callee, true);
+            continue;
+        }
+
         if tcx.is_constructor(callee.def_id()) {
             trace!("constructors always have MIR");
             // Constructor functions cannot cause a query cycle.