AliasRelationDirection -> RelationDirection

compiler-errors · compiler-errors · commit 865a1685f4cf · 2024-02-22T15:49:50.000Z
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -572,28 +572,22 @@ impl<'bccx, 'tcx> ObligationEmittingRelation<'tcx> for NllTypeRelating<'_, 'bccx
         );
     }
 
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection {
+    fn alias_relate_direction(&self) -> ty::RelationDirection {
         unreachable!("manually overridden to handle ty::Variance::Contravariant ambient variance")
     }
 
     fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
         self.register_predicates([ty::Binder::dummy(match self.ambient_variance {
-            ty::Variance::Covariant => ty::PredicateKind::AliasRelate(
-                a.into(),
-                b.into(),
-                ty::AliasRelationDirection::Subtype,
-            ),
+            ty::Variance::Covariant => {
+                ty::PredicateKind::AliasRelate(a.into(), b.into(), ty::RelationDirection::Subtype)
+            }
             // a :> b is b <: a
-            ty::Variance::Contravariant => ty::PredicateKind::AliasRelate(
-                b.into(),
-                a.into(),
-                ty::AliasRelationDirection::Subtype,
-            ),
-            ty::Variance::Invariant => ty::PredicateKind::AliasRelate(
-                a.into(),
-                b.into(),
-                ty::AliasRelationDirection::Equate,
-            ),
+            ty::Variance::Contravariant => {
+                ty::PredicateKind::AliasRelate(b.into(), a.into(), ty::RelationDirection::Subtype)
+            }
+            ty::Variance::Invariant => {
+                ty::PredicateKind::AliasRelate(a.into(), b.into(), ty::RelationDirection::Equate)
+            }
             ty::Variance::Bivariant => {
                 unreachable!("cannot defer an alias-relate goal with Bivariant variance (yet?)")
             }
diff --git a/compiler/rustc_infer/src/infer/relate/combine.rs b/compiler/rustc_infer/src/infer/relate/combine.rs
@@ -34,6 +34,7 @@ use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::relate::{RelateResult, TypeRelation};
 use rustc_middle::ty::{self, InferConst, ToPredicate, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::ty::{IntType, UintType};
+use rustc_middle::ty::{RelationDirection, TyVar};
 use rustc_span::Span;
 
 #[derive(Clone)]
@@ -246,7 +247,7 @@ impl<'tcx> InferCtxt<'tcx> {
                     ty::PredicateKind::AliasRelate(
                         a.into(),
                         b.into(),
-                        ty::AliasRelationDirection::Equate,
+                        ty::RelationDirection::Equate,
                     )
                 } else {
                     ty::PredicateKind::ConstEquate(a, b)
@@ -344,7 +345,7 @@ pub trait ObligationEmittingRelation<'tcx>: TypeRelation<'tcx> {
     fn register_predicates(&mut self, obligations: impl IntoIterator<Item: ToPredicate<'tcx>>);
 
     /// Register an obligation that both types must be related to each other according to
-    /// the [`ty::AliasRelationDirection`] given by [`ObligationEmittingRelation::alias_relate_direction`]
+    /// the [`ty::RelationDirection`] given by [`ObligationEmittingRelation::alias_relate_direction`]
     fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
         self.register_predicates([ty::Binder::dummy(ty::PredicateKind::AliasRelate(
             a.into(),
@@ -355,7 +356,7 @@ pub trait ObligationEmittingRelation<'tcx>: TypeRelation<'tcx> {
 
     /// Relation direction emitted for `AliasRelate` predicates, corresponding to the direction
     /// of the relation.
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection;
+    fn alias_relate_direction(&self) -> ty::RelationDirection;
 }
 
 fn int_unification_error<'tcx>(
diff --git a/compiler/rustc_infer/src/infer/relate/equate.rs b/compiler/rustc_infer/src/infer/relate/equate.rs
@@ -192,7 +192,7 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Equate<'_, '_, 'tcx> {
         self.fields.register_obligations(obligations);
     }
 
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection {
-        ty::AliasRelationDirection::Equate
+    fn alias_relate_direction(&self) -> ty::RelationDirection {
+        ty::RelationDirection::Equate
     }
 }
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -10,7 +10,7 @@ use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::visit::MaxUniverse;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_middle::ty::{AliasRelationDirection, InferConst, Term, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{InferConst, RelationDirection, Term, TypeVisitable, TypeVisitableExt};
 use rustc_span::Span;
 
 impl<'tcx> InferCtxt<'tcx> {
@@ -75,13 +75,13 @@ impl<'tcx> InferCtxt<'tcx> {
             if self.next_trait_solver() {
                 let (lhs, rhs, direction) = match ambient_variance {
                     ty::Variance::Invariant => {
-                        (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Equate)
+                        (generalized_ty.into(), source_ty.into(), RelationDirection::Equate)
                     }
                     ty::Variance::Covariant => {
-                        (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Subtype)
+                        (generalized_ty.into(), source_ty.into(), RelationDirection::Subtype)
                     }
                     ty::Variance::Contravariant => {
-                        (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
+                        (source_ty.into(), generalized_ty.into(), RelationDirection::Subtype)
                     }
                     ty::Variance::Bivariant => unreachable!("bivariant generalization"),
                 };
diff --git a/compiler/rustc_infer/src/infer/relate/glb.rs b/compiler/rustc_infer/src/infer/relate/glb.rs
@@ -151,8 +151,8 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Glb<'_, '_, 'tcx> {
         self.fields.register_obligations(obligations);
     }
 
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection {
+    fn alias_relate_direction(&self) -> ty::RelationDirection {
         // FIXME(deferred_projection_equality): This isn't right, I think?
-        ty::AliasRelationDirection::Equate
+        ty::RelationDirection::Equate
     }
 }
diff --git a/compiler/rustc_infer/src/infer/relate/lub.rs b/compiler/rustc_infer/src/infer/relate/lub.rs
@@ -151,8 +151,8 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Lub<'_, '_, 'tcx> {
         self.fields.register_obligations(obligations)
     }
 
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection {
+    fn alias_relate_direction(&self) -> ty::RelationDirection {
         // FIXME(deferred_projection_equality): This isn't right, I think?
-        ty::AliasRelationDirection::Equate
+        ty::RelationDirection::Equate
     }
 }
diff --git a/compiler/rustc_infer/src/infer/relate/sub.rs b/compiler/rustc_infer/src/infer/relate/sub.rs
@@ -216,7 +216,7 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Sub<'_, '_, 'tcx> {
         self.fields.register_obligations(obligations);
     }
 
-    fn alias_relate_direction(&self) -> ty::AliasRelationDirection {
-        ty::AliasRelationDirection::Subtype
+    fn alias_relate_direction(&self) -> ty::RelationDirection {
+        ty::RelationDirection::Subtype
     }
 }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -655,14 +655,17 @@ impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {
     }
 }
 
-impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection {
+impl<'tcx> Stable<'tcx> for ty::RelationDirection {
     type T = stable_mir::ty::AliasRelationDirection;
 
     fn stable(&self, _: &mut Tables<'_>) -> Self::T {
-        use rustc_middle::ty::AliasRelationDirection::*;
         match self {
-            Equate => stable_mir::ty::AliasRelationDirection::Equate,
-            Subtype => stable_mir::ty::AliasRelationDirection::Subtype,
+            rustc_middle::ty::RelationDirection::Equate => {
+                stable_mir::ty::AliasRelationDirection::Equate
+            }
+            rustc_middle::ty::RelationDirection::Subtype => {
+                stable_mir::ty::AliasRelationDirection::Subtype
+            }
         }
     }
 }
diff --git a/compiler/rustc_trait_selection/src/solve/alias_relate.rs b/compiler/rustc_trait_selection/src/solve/alias_relate.rs
@@ -29,7 +29,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
     #[instrument(level = "debug", skip(self), ret)]
     pub(super) fn compute_alias_relate_goal(
         &mut self,
-        goal: Goal<'tcx, (ty::Term<'tcx>, ty::Term<'tcx>, ty::AliasRelationDirection)>,
+        goal: Goal<'tcx, (ty::Term<'tcx>, ty::Term<'tcx>, ty::RelationDirection)>,
     ) -> QueryResult<'tcx> {
         let tcx = self.tcx();
         let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;
@@ -43,8 +43,8 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         };
 
         let variance = match direction {
-            ty::AliasRelationDirection::Equate => ty::Variance::Invariant,
-            ty::AliasRelationDirection::Subtype => ty::Variance::Covariant,
+            ty::RelationDirection::Equate => ty::Variance::Invariant,
+            ty::RelationDirection::Subtype => ty::Variance::Covariant,
         };
 
         match (lhs.to_alias_ty(tcx), rhs.to_alias_ty(tcx)) {
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -21,7 +21,7 @@ use rustc_middle::traits::solve::{
     CanonicalResponse, Certainty, ExternalConstraintsData, Goal, GoalSource, IsNormalizesToHack,
     QueryResult, Response,
 };
-use rustc_middle::ty::{self, AliasRelationDirection, Ty, TyCtxt, UniverseIndex};
+use rustc_middle::ty::{self, RelationDirection, Ty, TyCtxt, UniverseIndex};
 use rustc_middle::ty::{
     CoercePredicate, RegionOutlivesPredicate, SubtypePredicate, TypeOutlivesPredicate,
 };
@@ -280,7 +280,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
                 ty::PredicateKind::AliasRelate(
                     ty.into(),
                     normalized_ty.into(),
-                    AliasRelationDirection::Equate,
+                    RelationDirection::Equate,
                 ),
             );
             self.add_goal(GoalSource::Misc, alias_relate_goal);
diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs
@@ -81,7 +81,7 @@ impl<'tcx> NormalizationFolder<'_, 'tcx> {
             ty::PredicateKind::AliasRelate(
                 alias_ty.into(),
                 new_infer_ty.into(),
-                ty::AliasRelationDirection::Equate,
+                ty::RelationDirection::Equate,
             ),
         );
 
diff --git a/compiler/rustc_trait_selection/src/solve/project_goals.rs b/compiler/rustc_trait_selection/src/solve/project_goals.rs
@@ -29,7 +29,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
             ty::PredicateKind::AliasRelate(
                 projection_term,
                 goal.predicate.term,
-                ty::AliasRelationDirection::Equate,
+                ty::RelationDirection::Equate,
             ),
         );
         self.add_goal(GoalSource::Misc, goal);
diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
@@ -34,7 +34,7 @@ impl<'tcx> At<'_, 'tcx> {
                 ty::PredicateKind::AliasRelate(
                     ty.into(),
                     new_infer_ty.into(),
-                    ty::AliasRelationDirection::Equate,
+                    ty::RelationDirection::Equate,
                 ),
             );
 
diff --git a/compiler/rustc_type_ir/src/macros.rs b/compiler/rustc_type_ir/src/macros.rs
@@ -49,7 +49,7 @@ TrivialTypeTraversalImpls! {
     u64,
     String,
     crate::DebruijnIndex,
-    crate::AliasRelationDirection,
+    crate::RelationDirection,
     crate::UniverseIndex,
     crate::Mutability,
     crate::Movability,
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -160,7 +160,7 @@ pub enum PredicateKind<I: Interner> {
     /// This predicate requires two terms to be equal to eachother.
     ///
     /// Only used for new solver
-    AliasRelate(I::Term, I::Term, AliasRelationDirection),
+    AliasRelate(I::Term, I::Term, RelationDirection),
 }
 
 impl<I: Interner> TypeFoldable<I> for PredicateKind<I>
@@ -228,16 +228,16 @@ where
 
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Copy)]
 #[cfg_attr(feature = "nightly", derive(HashStable_NoContext, Encodable, Decodable))]
-pub enum AliasRelationDirection {
+pub enum RelationDirection {
     Equate,
     Subtype,
 }
 
-impl std::fmt::Display for AliasRelationDirection {
+impl std::fmt::Display for RelationDirection {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            AliasRelationDirection::Equate => write!(f, "=="),
-            AliasRelationDirection::Subtype => write!(f, "<:"),
+            RelationDirection::Equate => write!(f, "=="),
+            RelationDirection::Subtype => write!(f, "<:"),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Equate<'_, '_, 'tcx> {`
`192`	`192`	`self.fields.register_obligations(obligations);`
`193`	`193`	`}`
`194`	`194`
`195`		`- fn alias_relate_direction(&self) -> ty::AliasRelationDirection {`
`196`		`- ty::AliasRelationDirection::Equate`
	`195`	`+ fn alias_relate_direction(&self) -> ty::RelationDirection {`
	`196`	`+ ty::RelationDirection::Equate`
`197`	`197`	`}`
`198`	`198`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,8 +151,8 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Glb<'_, '_, 'tcx> {`
`151`	`151`	`self.fields.register_obligations(obligations);`
`152`	`152`	`}`
`153`	`153`
`154`		`- fn alias_relate_direction(&self) -> ty::AliasRelationDirection {`
	`154`	`+ fn alias_relate_direction(&self) -> ty::RelationDirection {`
`155`	`155`	`// FIXME(deferred_projection_equality): This isn't right, I think?`
`156`		`- ty::AliasRelationDirection::Equate`
	`156`	`+ ty::RelationDirection::Equate`
`157`	`157`	`}`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for Sub<'_, '_, 'tcx> {`
`216`	`216`	`self.fields.register_obligations(obligations);`
`217`	`217`	`}`
`218`	`218`
`219`		`- fn alias_relate_direction(&self) -> ty::AliasRelationDirection {`
`220`		`- ty::AliasRelationDirection::Subtype`
	`219`	`+ fn alias_relate_direction(&self) -> ty::RelationDirection {`
	`220`	`+ ty::RelationDirection::Subtype`
`221`	`221`	`}`
`222`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -655,14 +655,17 @@ impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {`
`655`	`655`	`}`
`656`	`656`	`}`
`657`	`657`
`658`		`-impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection {`
	`658`	`+impl<'tcx> Stable<'tcx> for ty::RelationDirection {`
`659`	`659`	`type T = stable_mir::ty::AliasRelationDirection;`
`660`	`660`
`661`	`661`	`fn stable(&self, _: &mut Tables<'_>) -> Self::T {`
`662`		`- use rustc_middle::ty::AliasRelationDirection::*;`
`663`	`662`	`match self {`
`664`		`- Equate => stable_mir::ty::AliasRelationDirection::Equate,`
`665`		`- Subtype => stable_mir::ty::AliasRelationDirection::Subtype,`
	`663`	`+ rustc_middle::ty::RelationDirection::Equate => {`
	`664`	`+ stable_mir::ty::AliasRelationDirection::Equate`
	`665`	`+ }`
	`666`	`+ rustc_middle::ty::RelationDirection::Subtype => {`
	`667`	`+ stable_mir::ty::AliasRelationDirection::Subtype`
	`668`	`+ }`
`666`	`669`	`}`
`667`	`670`	`}`
`668`	`671`	`}`