Remove unnecessary StructurallyRelateAliases from CombineFields/TypeRelating

Author: compiler-errors

compiler/rustc_infer/src/infer/at.rs

@@ -29,7 +29,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::{Const, ImplSubject};
 
 use super::*;
-use crate::infer::relate::{Relate, StructurallyRelateAliases, TypeRelation};
+use crate::infer::relate::{Relate, TypeRelation};
 use crate::traits::Obligation;
 
 /// Whether we should define opaque types or just treat them opaquely.
@@ -169,7 +169,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
         T: Relate<TyCtxt<'tcx>>,
     {
         let mut fields = CombineFields::new(self.infcx, trace, self.param_env, define_opaque_types);
-        fields.equate(StructurallyRelateAliases::No).relate(expected, actual)?;
+        fields.equate().relate(expected, actual)?;
         Ok(InferOk {
             value: (),
             obligations: fields

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

@@ -22,7 +22,6 @@ use rustc_middle::traits::solve::Goal;
 pub use rustc_middle::ty::relate::combine::*;
 use rustc_middle::ty::{self, TyCtxt, Upcast};
 
-use super::StructurallyRelateAliases;
 use super::glb::Glb;
 use super::lub::Lub;
 use super::type_relating::TypeRelating;
@@ -68,19 +67,16 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
         self.infcx.tcx
     }
 
-    pub fn equate<'a>(
-        &'a mut self,
-        structurally_relate_aliases: StructurallyRelateAliases,
-    ) -> TypeRelating<'a, 'infcx, 'tcx> {
-        TypeRelating::new(self, structurally_relate_aliases, ty::Invariant)
+    pub fn equate<'a>(&'a mut self) -> TypeRelating<'a, 'infcx, 'tcx> {
+        TypeRelating::new(self, ty::Invariant)
     }
 
     pub fn sub<'a>(&'a mut self) -> TypeRelating<'a, 'infcx, 'tcx> {
-        TypeRelating::new(self, StructurallyRelateAliases::No, ty::Covariant)
+        TypeRelating::new(self, ty::Covariant)
     }
 
     pub fn sup<'a>(&'a mut self) -> TypeRelating<'a, 'infcx, 'tcx> {
-        TypeRelating::new(self, StructurallyRelateAliases::No, ty::Contravariant)
+        TypeRelating::new(self, ty::Contravariant)
     }
 
     pub fn lub<'a>(&'a mut self) -> Lub<'a, 'infcx, 'tcx> {

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

@@ -36,7 +36,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Glb<'_, '_, 'tcx> {
         b: T,
     ) -> RelateResult<'tcx, T> {
         match variance {
-            ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
+            ty::Invariant => self.fields.equate().relate(a, b),
             ty::Covariant => self.relate(a, b),
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),

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

@@ -36,7 +36,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Lub<'_, '_, 'tcx> {
         b: T,
     ) -> RelateResult<'tcx, T> {
         match variance {
-            ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
+            ty::Invariant => self.fields.equate().relate(a, b),
             ty::Covariant => self.relate(a, b),
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),

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

@@ -15,17 +15,15 @@ use crate::infer::{DefineOpaqueTypes, InferCtxt, SubregionOrigin};
 /// Enforce that `a` is equal to or a subtype of `b`.
 pub struct TypeRelating<'combine, 'a, 'tcx> {
     fields: &'combine mut CombineFields<'a, 'tcx>,
-    structurally_relate_aliases: StructurallyRelateAliases,
     ambient_variance: ty::Variance,
 }
 
 impl<'combine, 'infcx, 'tcx> TypeRelating<'combine, 'infcx, 'tcx> {
     pub fn new(
         f: &'combine mut CombineFields<'infcx, 'tcx>,
-        structurally_relate_aliases: StructurallyRelateAliases,
         ambient_variance: ty::Variance,
     ) -> TypeRelating<'combine, 'infcx, 'tcx> {
-        TypeRelating { fields: f, structurally_relate_aliases, ambient_variance }
+        TypeRelating { fields: f, ambient_variance }
     }
 }
 
@@ -300,7 +298,7 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for TypeRelating<'_, '_, '
     }
 
     fn structurally_relate_aliases(&self) -> StructurallyRelateAliases {
-        self.structurally_relate_aliases
+        StructurallyRelateAliases::No
     }
 
     fn register_predicates(