fmt

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -26,7 +26,12 @@ impl<'combine, 'infcx, 'tcx> TypeRelating<'combine, 'infcx, 'tcx> {
         structurally_relate_aliases: StructurallyRelateAliases,
         ambient_variance: ty::Variance,
     ) -> TypeRelating<'combine, 'infcx, 'tcx> {
-        TypeRelating { fields: f, structurally_relate_aliases, ambient_variance, cache: Default::default() }
+        TypeRelating {
+            fields: f,
+            structurally_relate_aliases,
+            ambient_variance,
+            cache: Default::default(),
+        }
     }
 }
 
@@ -76,11 +81,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, '_, 'tcx> {
             return Ok(a);
         }
 
-
         let infcx = self.fields.infcx;
         let a = infcx.shallow_resolve(a);
         let b = infcx.shallow_resolve(b);
-        
+
         if self.cache.contains(&(self.ambient_variance, a, b)) {
             return Ok(a);
         }

compiler/rustc_infer/src/infer/resolve.rs

@@ -36,7 +36,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for OpportunisticVarResolver<'a, 'tcx> {
         if let Some(&ty) = self.cache.get(&t) {
             return ty;
         }
-        
+
         let res = if !t.has_non_region_infer() {
             t // micro-optimize -- if there is nothing in this type that this fold affects...
         } else {

compiler/rustc_next_trait_solver/src/resolve.rs

@@ -1,8 +1,8 @@
+use rustc_type_ir::data_structures::HashMap;
 use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::visit::TypeVisitableExt;
 use rustc_type_ir::{self as ty, InferCtxtLike, Interner};
-use rustc_type_ir::data_structures::HashMap;
 
 use crate::delegate::SolverDelegate;
 

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -585,18 +585,16 @@ where
 
     #[instrument(level = "trace", skip(self))]
     pub(super) fn add_normalizes_to_goal(&mut self, mut goal: Goal<I, ty::NormalizesTo<I>>) {
-        goal.predicate = goal
-            .predicate
-            .fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
+        goal.predicate =
+            goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
         self.inspect.add_normalizes_to_goal(self.delegate, self.max_input_universe, goal);
         self.nested_goals.normalizes_to_goals.push(goal);
     }
 
     #[instrument(level = "debug", skip(self))]
     pub(super) fn add_goal(&mut self, source: GoalSource, mut goal: Goal<I, I::Predicate>) {
-        goal.predicate = goal
-            .predicate
-            .fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
+        goal.predicate =
+            goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
         self.inspect.add_goal(self.delegate, self.max_input_universe, source, goal);
         self.nested_goals.goals.push((source, goal));
     }
@@ -681,7 +679,7 @@ where
                 if self.cache.contains(&t) {
                     return ControlFlow::Continue(());
                 }
-                
+
                 match t.kind() {
                     ty::Infer(ty::TyVar(vid)) => {
                         if let ty::TermKind::Ty(term) = self.term.kind() {
@@ -1035,7 +1033,7 @@ impl<'me, 'a, D, I> ReplaceAliasWithInfer<'me, 'a, D, I>
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
-    {
+{
     fn new(ecx: &'me mut EvalCtxt<'a, D>, param_env: I::ParamEnv) -> Self {
         ReplaceAliasWithInfer { ecx, param_env, cache: Default::default() }
     }

tests/ui/traits/next-solver/overflow/coherence-alias-hang.rs

@@ -3,7 +3,6 @@
 //@[ai_next] compile-flags: -Znext-solver
 //@[ia_next] compile-flags: -Znext-solver
 //@[ii_next] compile-flags: -Znext-solver
-// check-pass
 
 // Regression test for nalgebra hang <https://github.com/rust-lang/rust/issues/130056>.