fmt

lcnr · lcnr · commit 5631939ab867 · 2024-09-25T11:23:42.000+02:00
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/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);
         }
diff --git a/compiler/rustc_infer/src/infer/resolve.rs b/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 {
diff --git a/compiler/rustc_next_trait_solver/src/resolve.rs b/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;
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/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() }
     }
diff --git a/tests/ui/traits/next-solver/overflow/coherence-alias-hang.rs b/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>.
 

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,12 @@ impl<'combine, 'infcx, 'tcx> TypeRelating<'combine, 'infcx, 'tcx> {`
`26`	`26`	`structurally_relate_aliases: StructurallyRelateAliases,`
`27`	`27`	`ambient_variance: ty::Variance,`
`28`	`28`	`) -> TypeRelating<'combine, 'infcx, 'tcx> {`
`29`		`- TypeRelating { fields: f, structurally_relate_aliases, ambient_variance, cache: Default::default() }`
	`29`	`+ TypeRelating {`
	`30`	`+ fields: f,`
	`31`	`+ structurally_relate_aliases,`
	`32`	`+ ambient_variance,`
	`33`	`+ cache: Default::default(),`
	`34`	`+ }`
`30`	`35`	`}`
`31`	`36`	`}`
`32`	`37`
`@@ -76,11 +81,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, '_, 'tcx> {`
`76`	`81`	`return Ok(a);`
`77`	`82`	`}`
`78`	`83`
`79`		`-`
`80`	`84`	`let infcx = self.fields.infcx;`
`81`	`85`	`let a = infcx.shallow_resolve(a);`
`82`	`86`	`let b = infcx.shallow_resolve(b);`
`83`		`-`
	`87`	`+`
`84`	`88`	`if self.cache.contains(&(self.ambient_variance, a, b)) {`
`85`	`89`	`return Ok(a);`
`86`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for OpportunisticVarResolver<'a, 'tcx> {`
`36`	`36`	`if let Some(&ty) = self.cache.get(&t) {`
`37`	`37`	`return ty;`
`38`	`38`	`}`
`39`		`-`
	`39`	`+`
`40`	`40`	`let res = if !t.has_non_region_infer() {`
`41`	`41`	`t // micro-optimize -- if there is nothing in this type that this fold affects...`
`42`	`42`	`} else {`