Auto merge of #151374 - BoxyUwU:borrowck_cleanup_3, r=<try>

some more rustc_borrowck cleanups

Author: bors

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -343,8 +343,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             return;
         }
 
-        // FIXME: Ideally MIR types are normalized, but this is not always true.
-        let mir_ty = self.normalize(mir_ty, Locations::All(span));
+        // TODO: write a test that requires normalization. body locals arent necessarily normalized
+        // in the old solver so this *should* be possible to hit. See `equate_inputs_and_outputs` for
+        // a similar problem
 
         let cause = ObligationCause::dummy_with_span(span);
         let param_env = self.infcx.param_env;
@@ -353,6 +354,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             ConstraintCategory::Boring,
             type_op::custom::CustomTypeOp::new(
                 |ocx| {
+                    // The `AscribeUserType` query would normally emit a wf
+                    // obligation for the unnormalized user_ty here. This is
+                    // where the "incorrectly skips the WF checks we normally do"
+                    // happens
                     let user_ty = ocx.normalize(&cause, param_env, user_ty);
                     ocx.eq(&cause, param_env, user_ty, mir_ty)?;
                     Ok(())

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -173,38 +173,36 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             );
         }
 
-        // Return types are a bit more complex. They may contain opaque `impl Trait` types.
+        // Equate expected output ty with the type of the RETURN_PLACE in MIR
         let mir_output_ty = self.body.local_decls[RETURN_PLACE].ty;
         let output_span = self.body.local_decls[RETURN_PLACE].source_info.span;
         self.equate_normalized_input_or_output(normalized_output_ty, mir_output_ty, output_span);
     }
 
     #[instrument(skip(self), level = "debug")]
     fn equate_normalized_input_or_output(&mut self, a: Ty<'tcx>, b: Ty<'tcx>, span: Span) {
-        if let Err(_) =
-            self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)
-        {
-            // FIXME(jackh726): This is a hack. It's somewhat like
-            // `rustc_traits::normalize_after_erasing_regions`. Ideally, we'd
-            // like to normalize *before* inserting into `local_decls`, but
-            // doing so ends up causing some other trouble.
-            let b = self.normalize(b, Locations::All(span));
-
-            // Note: if we have to introduce new placeholders during normalization above, then we
-            // won't have added those universes to the universe info, which we would want in
-            // `relate_tys`.
-            if let Err(terr) =
-                self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)
-            {
-                span_mirbug!(
-                    self,
-                    Location::START,
-                    "equate_normalized_input_or_output: `{:?}=={:?}` failed with `{:?}`",
-                    a,
-                    b,
-                    terr
-                );
-            }
-        }
+        let b = match self.infcx.tcx.next_trait_solver_globally() {
+            true => b,
+            // FIXME(jackh726, BoxyUwU): This is a hack. `body.local_decls` are not necessarily
+            // normalized in the old solver due to not deeply normalizing in writeback. So we
+            // must re-normalize here.
+            //
+            // However, in most cases normalizing is unnecessary so we only do so if it may be
+            // necessary for type equality to hold. This leads to some (very minor) performance
+            // wins.
+            false => match self.eq_types(
+                a,
+                b,
+                Locations::All(span),
+                ConstraintCategory::BoringNoLocation,
+            ) {
+                Ok(_) => return,
+                Err(_) => self.normalize(b, Locations::All(span)),
+            },
+        };
+
+        debug!(?b);
+        self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)
+            .expect("equate_normalized_input_or_output unexpectedly failed");
     }
 }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -123,16 +123,19 @@ pub(crate) fn type_check<'tcx>(
         known_type_outlives_obligations,
     } = free_region_relations::create(infcx, universal_regions, &mut constraints);
 
-    let pre_obligations = infcx.take_registered_region_obligations();
-    assert!(
-        pre_obligations.is_empty(),
-        "there should be no incoming region obligations = {pre_obligations:#?}",
-    );
-    let pre_assumptions = infcx.take_registered_region_assumptions();
-    assert!(
-        pre_assumptions.is_empty(),
-        "there should be no incoming region assumptions = {pre_assumptions:#?}",
-    );
+    {
+        // Scope these variables so it's clear they're not used later
+        let pre_obligations = infcx.take_registered_region_obligations();
+        assert!(
+            pre_obligations.is_empty(),
+            "there should be no incoming region obligations = {pre_obligations:#?}",
+        );
+        let pre_assumptions = infcx.take_registered_region_assumptions();
+        assert!(
+            pre_assumptions.is_empty(),
+            "there should be no incoming region assumptions = {pre_assumptions:#?}",
+        );
+    }
 
     debug!(?normalized_inputs_and_output);
 

tests/ui/associated-types/normalization-generality-2.rs

@@ -1,4 +1,7 @@
 //@ build-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 // Ensures that we don't regress on "implementation is not general enough" when
 // normalizating under binders. Unlike `normalization-generality.rs`, this also produces

tests/ui/associated-types/normalization-generality.rs

@@ -1,4 +1,7 @@
 //@ build-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 // Ensures that we don't regress on "implementation is not general enough" when
 // normalizating under binders.

tests/ui/consts/missing_span_in_backtrace.rs

@@ -1,4 +1,7 @@
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 trait Yokeable<'a> {
     type Output: 'a;