Explicitly don't fold coroutine obligations in writeback

Author: compiler-errors

compiler/rustc_hir_typeck/src/writeback.rs

@@ -344,7 +344,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
     fn visit_local(&mut self, l: &'tcx hir::LetStmt<'tcx>) {
         intravisit::walk_local(self, l);
         let var_ty = self.fcx.local_ty(l.span, l.hir_id);
-        let var_ty = self.resolve(var_ty, &l.span);
+        let var_ty = self.resolve(var_ty, &l.span, true);
         self.write_ty_to_typeck_results(l.hir_id, var_ty);
     }
 
@@ -353,7 +353,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
         // If there are type checking errors, Type privacy pass will stop,
         // so we may not get the type from hid_id, see #104513
         if let Some(ty) = self.fcx.node_ty_opt(hir_ty.hir_id) {
-            let ty = self.resolve(ty, &hir_ty.span);
+            let ty = self.resolve(ty, &hir_ty.span, true);
             self.write_ty_to_typeck_results(hir_ty.hir_id, ty);
         }
     }
@@ -370,7 +370,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
         // the typeck results as there is not yet any part of the compiler that
         // needs this information.
         if let Some(ty) = self.fcx.node_ty_opt(inf_id) {
-            let ty = self.resolve(ty, &inf_span);
+            let ty = self.resolve(ty, &inf_span, true);
             self.write_ty_to_typeck_results(inf_id, ty);
         }
     }
@@ -387,7 +387,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                 .into_iter()
                 .map(|(&closure_def_id, data)| {
                     let closure_hir_id = self.tcx().local_def_id_to_hir_id(closure_def_id);
-                    let data = self.resolve(*data, &closure_hir_id);
+                    let data = self.resolve(*data, &closure_hir_id, true);
                     (closure_def_id, data)
                 })
                 .collect();
@@ -413,7 +413,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                                         captured_place.info.path_expr_id.unwrap_or_else(|| {
                                             self.tcx().local_def_id_to_hir_id(closure_def_id)
                                         });
-                                    self.resolve(captured_place.clone(), &locatable)
+                                    self.resolve(captured_place.clone(), &locatable, true)
                                 })
                                 .collect();
                             (*var_hir_id, min_list_wb)
@@ -438,7 +438,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                         .iter()
                         .map(|(place, cause, hir_id)| {
                             let locatable = self.tcx().local_def_id_to_hir_id(closure_def_id);
-                            let resolved_fake_read = self.resolve(place.clone(), &locatable);
+                            let resolved_fake_read = self.resolve(place.clone(), &locatable, true);
                             (resolved_fake_read, *cause, *hir_id)
                         })
                         .collect();
@@ -460,7 +460,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         for (local_id, origin) in fcx_closure_kind_origins {
             let hir_id = HirId { owner: common_hir_owner, local_id };
             let place_span = origin.0;
-            let place = self.resolve(origin.1.clone(), &place_span);
+            let place = self.resolve(origin.1.clone(), &place_span, true);
             self.typeck_results.closure_kind_origins_mut().insert(hir_id, (place_span, place));
         }
     }
@@ -548,7 +548,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         let fcx_typeck_results = self.fcx.typeck_results.borrow();
         assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner);
         for (predicate, cause) in &fcx_typeck_results.coroutine_stalled_predicates {
-            let (predicate, cause) = self.resolve((*predicate, cause.clone()), &cause.span);
+            let (predicate, cause) = self.resolve((*predicate, cause.clone()), &cause.span, false);
             self.typeck_results.coroutine_stalled_predicates.insert((predicate, cause));
         }
     }
@@ -565,8 +565,8 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         // fixpoint.
         let opaque_types = self.fcx.infcx.clone_opaque_types();
         for (opaque_type_key, hidden_type) in opaque_types {
-            let hidden_type = self.resolve(hidden_type, &hidden_type.span);
-            let opaque_type_key = self.resolve(opaque_type_key, &hidden_type.span);
+            let hidden_type = self.resolve(hidden_type, &hidden_type.span, true);
+            let opaque_type_key = self.resolve(opaque_type_key, &hidden_type.span, true);
 
             if !self.fcx.next_trait_solver() {
                 if let ty::Alias(ty::Opaque, alias_ty) = hidden_type.ty.kind()
@@ -612,13 +612,13 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
 
         // Resolve the type of the node with id `node_id`
         let n_ty = self.fcx.node_ty(hir_id);
-        let n_ty = self.resolve(n_ty, &span);
+        let n_ty = self.resolve(n_ty, &span, true);
         self.write_ty_to_typeck_results(hir_id, n_ty);
         debug!(?n_ty);
 
         // Resolve any generic parameters
         if let Some(args) = self.fcx.typeck_results.borrow().node_args_opt(hir_id) {
-            let args = self.resolve(args, &span);
+            let args = self.resolve(args, &span, true);
             debug!("write_args_to_tcx({:?}, {:?})", hir_id, args);
             assert!(!args.has_infer() && !args.has_placeholders());
             self.typeck_results.node_args_mut().insert(hir_id, args);
@@ -634,7 +634,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
             }
 
             Some(adjustment) => {
-                let resolved_adjustment = self.resolve(adjustment, &span);
+                let resolved_adjustment = self.resolve(adjustment, &span, true);
                 debug!(?resolved_adjustment);
                 self.typeck_results.adjustments_mut().insert(hir_id, resolved_adjustment);
             }
@@ -668,7 +668,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
             }
 
             Some(adjustment) => {
-                let resolved_adjustment = self.resolve(adjustment, &span);
+                let resolved_adjustment = self.resolve(adjustment, &span, true);
                 debug!(?resolved_adjustment);
                 self.typeck_results.pat_adjustments_mut().insert(hir_id, resolved_adjustment);
             }
@@ -692,7 +692,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
 
         for (local_id, &fn_sig) in fcx_liberated_fn_sigs {
             let hir_id = HirId { owner: common_hir_owner, local_id };
-            let fn_sig = self.resolve(fn_sig, &hir_id);
+            let fn_sig = self.resolve(fn_sig, &hir_id, true);
             self.typeck_results.liberated_fn_sigs_mut().insert(hir_id, fn_sig);
         }
     }
@@ -706,7 +706,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
 
         for (local_id, ftys) in fcx_fru_field_types {
             let hir_id = HirId { owner: common_hir_owner, local_id };
-            let ftys = self.resolve(ftys.clone(), &hir_id);
+            let ftys = self.resolve(ftys.clone(), &hir_id, true);
             self.typeck_results.fru_field_types_mut().insert(hir_id, ftys);
         }
     }
@@ -720,17 +720,18 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
             fcx_typeck_results.offset_of_data().items_in_stable_order()
         {
             let hir_id = HirId { owner: common_hir_owner, local_id };
-            let container = self.resolve(container, &hir_id);
+            let container = self.resolve(container, &hir_id, true);
             self.typeck_results.offset_of_data_mut().insert(hir_id, (container, indices.clone()));
         }
     }
 
-    fn resolve<T>(&mut self, value: T, span: &dyn Locatable) -> T
+    fn resolve<T>(&mut self, value: T, span: &dyn Locatable, should_normalize: bool) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
         let value = self.fcx.resolve_vars_if_possible(value);
-        let value = value.fold_with(&mut Resolver::new(self.fcx, span, self.body));
+        let value =
+            value.fold_with(&mut Resolver::new(self.fcx, span, self.body, should_normalize));
         assert!(!value.has_infer());
 
         // We may have introduced e.g. `ty::Error`, if inference failed, make sure
@@ -774,8 +775,9 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
         fcx: &'cx FnCtxt<'cx, 'tcx>,
         span: &'cx dyn Locatable,
         body: &'tcx hir::Body<'tcx>,
+        should_normalize: bool,
     ) -> Resolver<'cx, 'tcx> {
-        Resolver { fcx, span, body, should_normalize: fcx.next_trait_solver() }
+        Resolver { fcx, span, body, should_normalize }
     }
 
     fn report_error(&self, p: impl Into<ty::GenericArg<'tcx>>) -> ErrorGuaranteed {
@@ -805,10 +807,9 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
         T: Into<ty::GenericArg<'tcx>> + TypeSuperFoldable<TyCtxt<'tcx>> + Copy,
     {
         let tcx = self.fcx.tcx;
-        // We must deeply normalize in the new solver, since later lints
-        // expect that types that show up in the typeck are fully
-        // normalized.
-        let mut value = if self.should_normalize {
+        // We must deeply normalize in the new solver, since later lints expect
+        // that types that show up in the typeck are fully normalized.
+        let mut value = if self.should_normalize && self.fcx.next_trait_solver() {
             let body_id = tcx.hir_body_owner_def_id(self.body.id());
             let cause = ObligationCause::misc(self.span.to_span(tcx), body_id);
             let at = self.fcx.at(&cause, self.fcx.param_env);
@@ -868,13 +869,11 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {
     }
 
     fn fold_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
-        // Do not normalize predicates in the new solver. The new solver is
-        // supposed to handle unnormalized predicates and incorrectly normalizing
-        // them can be unsound, e.g. for `WellFormed` predicates.
-        let prev = mem::replace(&mut self.should_normalize, false);
-        let predicate = predicate.super_fold_with(self);
-        self.should_normalize = prev;
-        predicate
+        assert!(
+            !self.should_normalize,
+            "normalizing predicats in writeback is not generally sound"
+        );
+        predicate.super_fold_with(self)
     }
 }