Experimental impl of a better way of handling coroutines in dtorck constraint

Author: compiler-errors

compiler/rustc_infer/src/infer/mod.rs

@@ -1267,10 +1267,12 @@ impl<'tcx> InferCtxt<'tcx> {
             // to handle them without proper canonicalization. This means we may cause cycle
             // errors and fail to reveal opaques while inside of bodies. We should rename this
             // function and require explicit comments on all use-sites in the future.
-            ty::TypingMode::Analysis { defining_opaque_types_and_generators: _ }
-            | ty::TypingMode::Borrowck { defining_opaque_types: _ } => {
+            ty::TypingMode::Analysis { defining_opaque_types_and_generators: _ } => {
                 TypingMode::non_body_analysis()
             }
+            ty::TypingMode::Borrowck { defining_opaque_types: _ } => {
+                TypingMode::Borrowck { defining_opaque_types: ty::List::empty() }
+            }
             mode @ (ty::TypingMode::Coherence
             | ty::TypingMode::PostBorrowckAnalysis { .. }
             | ty::TypingMode::PostAnalysis) => mode,

compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs

@@ -345,12 +345,10 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
 
             // While we conservatively assume that all coroutines require drop
             // to avoid query cycles during MIR building, we can be more precise
-            // here and check the specific components of the coroutines. This
-            // includes the witness types, upvars, *and* the resume ty.
-            let typing_env = tcx.erase_regions(typing_env);
-            let needs_drop = args.witness().needs_drop(tcx, typing_env)
-                || args.upvar_tys().iter().any(|ty| ty.needs_drop(tcx, typing_env))
-                || args.resume_ty().needs_drop(tcx, typing_env);
+            // here by re-checking in a `TypingMode::Borrowck` environment. This
+            // will recurse into the coroutine witness (which we can now access
+            // without cycles).
+            let needs_drop = ty.needs_drop(tcx, tcx.erase_regions(typing_env));
             if needs_drop {
                 constraints.outlives.extend(args.upvar_tys().iter().map(ty::GenericArg::from));
                 constraints.outlives.push(args.resume_ty().into());

compiler/rustc_traits/src/dropck_outlives.rs

@@ -23,7 +23,6 @@ fn dropck_outlives<'tcx>(
     canonical_goal: CanonicalDropckOutlivesGoal<'tcx>,
 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>, NoSolution> {
     debug!("dropck_outlives(goal={:#?})", canonical_goal);
-
     tcx.infer_ctxt().enter_canonical_trait_query(&canonical_goal, |ocx, goal| {
         compute_dropck_outlives_inner(ocx, goal, DUMMY_SP)
     })

compiler/rustc_ty_utils/src/needs_drop.rs

@@ -101,9 +101,6 @@ fn has_significant_drop_raw<'tcx>(
 struct NeedsDropTypes<'tcx, F> {
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
-    /// Whether to reveal coroutine witnesses, this is set
-    /// to `false` unless we compute `needs_drop` for a coroutine witness.
-    reveal_coroutine_witnesses: bool,
     query_ty: Ty<'tcx>,
     seen_tys: FxHashSet<Ty<'tcx>>,
     /// A stack of types left to process, and the recursion depth when we
@@ -131,7 +128,6 @@ impl<'tcx, F> NeedsDropTypes<'tcx, F> {
         Self {
             tcx,
             typing_env,
-            reveal_coroutine_witnesses: exhaustive,
             seen_tys,
             query_ty: ty,
             unchecked_tys: vec![(ty, 0)],
@@ -196,15 +192,28 @@ where
                     // need to be dropped, and only require the captured types to be live
                     // if they do.
                     ty::Coroutine(_, args) => {
-                        if self.reveal_coroutine_witnesses {
-                            queue_type(self, args.as_coroutine().witness());
-                        } else {
-                            return Some(self.always_drop_component(ty));
+                        for arg in args.as_coroutine().upvar_tys() {
+                            queue_type(self, arg);
+                        }
+                        queue_type(self, args.as_coroutine().resume_ty());
+                        match self.typing_env.typing_mode {
+                            ty::TypingMode::Coherence => {
+                                unreachable!("coherence should not be considering drops")
+                            }
+                            ty::TypingMode::Analysis { .. } => {
+                                return Some(
+                                    self.always_drop_component(args.as_coroutine().witness()),
+                                );
+                            }
+                            ty::TypingMode::Borrowck { .. }
+                            | ty::TypingMode::PostBorrowckAnalysis { .. }
+                            | ty::TypingMode::PostAnalysis => {
+                                queue_type(self, args.as_coroutine().witness());
+                            }
                         }
                     }
                     ty::CoroutineWitness(def_id, args) => {
                         if let Some(witness) = tcx.mir_coroutine_witnesses(def_id) {
-                            self.reveal_coroutine_witnesses = true;
                             for field_ty in &witness.field_tys {
                                 queue_type(
                                     self,

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -117,11 +117,11 @@ impl<I: Interner> TypingMode<I> {
     }
 
     pub fn borrowck(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
-        let defining_opaque_types = cx.opaque_types_defined_by(body_def_id);
-        if defining_opaque_types.is_empty() {
+        // N.B. we can only use an analysis env if there are no coroutines defined.
+        if cx.opaque_types_and_coroutines_defined_by(body_def_id).is_empty() {
             TypingMode::non_body_analysis()
         } else {
-            TypingMode::Borrowck { defining_opaque_types }
+            TypingMode::Borrowck { defining_opaque_types: cx.opaque_types_defined_by(body_def_id) }
         }
     }