Fallout from removing a_is_expected

compiler-errors · compiler-errors · commit d4356b8d6d8a · 2024-02-28T17:41:18.000Z
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -160,8 +160,7 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
             ),
         };
         let cause = ObligationCause::dummy_with_span(self.span());
-        let obligations =
-            infcx.handle_opaque_type(a, b, true, &cause, self.param_env())?.obligations;
+        let obligations = infcx.handle_opaque_type(a, b, &cause, self.param_env())?.obligations;
         self.register_obligations(obligations);
         Ok(())
     }
@@ -330,10 +329,6 @@ impl<'bccx, 'tcx> TypeRelation<'tcx> for NllTypeRelating<'_, 'bccx, 'tcx> {
         "nll::subtype"
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     #[instrument(skip(self, info), level = "trace", ret)]
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -2669,10 +2669,6 @@ impl<'tcx> TypeRelation<'tcx> for SameTypeModuloInfer<'_, 'tcx> {
         "SameTypeModuloInfer"
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     fn relate_with_variance<T: relate::Relate<'tcx>>(
         &mut self,
         _variance: ty::Variance,
diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs
@@ -78,9 +78,7 @@ impl<'tcx> InferCtxt<'tcx> {
                         span,
                     });
                     obligations.extend(
-                        self.handle_opaque_type(ty, ty_var, true, &cause, param_env)
-                            .unwrap()
-                            .obligations,
+                        self.handle_opaque_type(ty, ty_var, &cause, param_env).unwrap().obligations,
                     );
                     ty_var
                 }
@@ -94,14 +92,12 @@ impl<'tcx> InferCtxt<'tcx> {
         &self,
         a: Ty<'tcx>,
         b: Ty<'tcx>,
-        a_is_expected: bool,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> InferResult<'tcx, ()> {
         if a.references_error() || b.references_error() {
             return Ok(InferOk { value: (), obligations: vec![] });
         }
-        let (a, b) = if a_is_expected { (a, b) } else { (b, a) };
         let process = |a: Ty<'tcx>, b: Ty<'tcx>| match *a.kind() {
             ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) if def_id.is_local() => {
                 let def_id = def_id.expect_local();
diff --git a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
@@ -144,10 +144,6 @@ impl<'tcx> TypeRelation<'tcx> for MatchAgainstHigherRankedOutlives<'tcx> {
         self.tcx
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    } // irrelevant
-
     #[instrument(level = "trace", skip(self))]
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
diff --git a/compiler/rustc_infer/src/infer/relate/combine.rs b/compiler/rustc_infer/src/infer/relate/combine.rs
@@ -57,7 +57,6 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         R: ObligationEmittingRelation<'tcx>,
     {
-        let a_is_expected = relation.a_is_expected();
         debug_assert!(!a.has_escaping_bound_vars());
         debug_assert!(!b.has_escaping_bound_vars());
 
@@ -68,20 +67,20 @@ impl<'tcx> InferCtxt<'tcx> {
                     .borrow_mut()
                     .int_unification_table()
                     .unify_var_var(a_id, b_id)
-                    .map_err(|e| int_unification_error(a_is_expected, e))?;
+                    .map_err(|e| int_unification_error(true, e))?;
                 Ok(a)
             }
             (&ty::Infer(ty::IntVar(v_id)), &ty::Int(v)) => {
-                self.unify_integral_variable(a_is_expected, v_id, IntType(v))
+                self.unify_integral_variable(true, v_id, IntType(v))
             }
             (&ty::Int(v), &ty::Infer(ty::IntVar(v_id))) => {
-                self.unify_integral_variable(!a_is_expected, v_id, IntType(v))
+                self.unify_integral_variable(!true, v_id, IntType(v))
             }
             (&ty::Infer(ty::IntVar(v_id)), &ty::Uint(v)) => {
-                self.unify_integral_variable(a_is_expected, v_id, UintType(v))
+                self.unify_integral_variable(true, v_id, UintType(v))
             }
             (&ty::Uint(v), &ty::Infer(ty::IntVar(v_id))) => {
-                self.unify_integral_variable(!a_is_expected, v_id, UintType(v))
+                self.unify_integral_variable(!true, v_id, UintType(v))
             }
 
             // Relate floating-point variables to other types
@@ -90,14 +89,14 @@ impl<'tcx> InferCtxt<'tcx> {
                     .borrow_mut()
                     .float_unification_table()
                     .unify_var_var(a_id, b_id)
-                    .map_err(|e| float_unification_error(a_is_expected, e))?;
+                    .map_err(|e| float_unification_error(true, e))?;
                 Ok(a)
             }
             (&ty::Infer(ty::FloatVar(v_id)), &ty::Float(v)) => {
-                self.unify_float_variable(a_is_expected, v_id, v)
+                self.unify_float_variable(true, v_id, v)
             }
             (&ty::Float(v), &ty::Infer(ty::FloatVar(v_id))) => {
-                self.unify_float_variable(!a_is_expected, v_id, v)
+                self.unify_float_variable(!true, v_id, v)
             }
 
             // We don't expect `TyVar` or `Fresh*` vars at this point with lazy norm.
@@ -130,7 +129,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
             // All other cases of inference are errors
             (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
-                Err(TypeError::Sorts(ty::relate::expected_found(relation, a, b)))
+                Err(TypeError::Sorts(ty::relate::expected_found(a, b)))
             }
 
             // During coherence, opaque types should be treated as *possibly*
@@ -228,12 +227,12 @@ impl<'tcx> InferCtxt<'tcx> {
             }
 
             (ty::ConstKind::Infer(InferConst::Var(vid)), _) => {
-                self.instantiate_const_var(relation, relation.a_is_expected(), vid, b)?;
+                self.instantiate_const_var(relation, true, vid, b)?;
                 Ok(b)
             }
 
             (_, ty::ConstKind::Infer(InferConst::Var(vid))) => {
-                self.instantiate_const_var(relation, !relation.a_is_expected(), vid, a)?;
+                self.instantiate_const_var(relation, false, vid, a)?;
                 Ok(a)
             }
 
@@ -250,8 +249,6 @@ impl<'tcx> InferCtxt<'tcx> {
             {
                 match relation.structurally_relate_aliases() {
                     StructurallyRelateAliases::No => {
-                        let (a, b) = if relation.a_is_expected() { (a, b) } else { (b, a) };
-
                         relation.register_predicates([if self.next_trait_solver() {
                             ty::PredicateKind::AliasRelate(
                                 a.into(),
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -130,7 +130,7 @@ impl<'tcx> InferCtxt<'tcx> {
             // instantiate_ty_var(?b, A) # expected and variance flipped
             // A rel A'
             // ```
-            if target_is_expected == relation.a_is_expected() {
+            if target_is_expected {
                 relation.relate(generalized_ty, source_ty)?;
             } else {
                 debug!("flip relation");
@@ -206,7 +206,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
         // HACK: make sure that we `a_is_expected` continues to be
         // correct when relating the generalized type with the source.
-        if target_is_expected == relation.a_is_expected() {
+        if target_is_expected {
             relation.relate_with_variance(
                 ty::Variance::Invariant,
                 ty::VarianceDiagInfo::default(),
@@ -398,10 +398,6 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
         "Generalizer"
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     fn relate_item_args(
         &mut self,
         item_def_id: DefId,
diff --git a/compiler/rustc_infer/src/infer/relate/glb.rs b/compiler/rustc_infer/src/infer/relate/glb.rs
@@ -30,10 +30,6 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
         self.fields.tcx()
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
         variance: ty::Variance,
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -116,9 +116,7 @@ where
                 && !this.infcx().next_trait_solver() =>
         {
             this.register_obligations(
-                infcx
-                    .handle_opaque_type(a, b, this.a_is_expected(), this.cause(), this.param_env())?
-                    .obligations,
+                infcx.handle_opaque_type(a, b, this.cause(), this.param_env())?.obligations,
             );
             Ok(a)
         }
diff --git a/compiler/rustc_infer/src/infer/relate/lub.rs b/compiler/rustc_infer/src/infer/relate/lub.rs
@@ -30,10 +30,6 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
         self.fields.tcx()
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
         variance: ty::Variance,
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs
@@ -35,10 +35,6 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
         self.fields.infcx.tcx
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    }
-
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
         variance: ty::Variance,
@@ -139,7 +135,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
             {
                 self.fields.obligations.extend(
                     infcx
-                        .handle_opaque_type(a, b, true, &self.fields.trace.cause, self.param_env())?
+                        .handle_opaque_type(a, b, &self.fields.trace.cause, self.param_env())?
                         .obligations,
                 );
             }
diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs
@@ -37,10 +37,6 @@ impl<'tcx> TypeRelation<'tcx> for MatchAgainstFreshVars<'tcx> {
         self.tcx
     }
 
-    fn a_is_expected(&self) -> bool {
-        true
-    } // irrelevant
-
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
         _: ty::Variance,
@@ -75,7 +71,7 @@ impl<'tcx> TypeRelation<'tcx> for MatchAgainstFreshVars<'tcx> {
             ) => Ok(a),
 
             (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
-                Err(TypeError::Sorts(relate::expected_found(self, a, b)))
+                Err(TypeError::Sorts(relate::expected_found(a, b)))
             }
 
             (&ty::Error(guar), _) | (_, &ty::Error(guar)) => Ok(Ty::new_error(self.tcx(), guar)),
@@ -100,7 +96,7 @@ impl<'tcx> TypeRelation<'tcx> for MatchAgainstFreshVars<'tcx> {
             }
 
             (ty::ConstKind::Infer(_), _) | (_, ty::ConstKind::Infer(_)) => {
-                return Err(TypeError::ConstMismatch(relate::expected_found(self, a, b)));
+                return Err(TypeError::ConstMismatch(relate::expected_found(a, b)));
             }
 
             _ => {}
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,6 @@ impl<'tcx> InferCtxt<'tcx> {`
`57`	`57`	`where`
`58`	`58`	`R: ObligationEmittingRelation<'tcx>,`
`59`	`59`	`{`
`60`		`- let a_is_expected = relation.a_is_expected();`
`61`	`60`	`debug_assert!(!a.has_escaping_bound_vars());`
`62`	`61`	`debug_assert!(!b.has_escaping_bound_vars());`
`63`	`62`
`@@ -68,20 +67,20 @@ impl<'tcx> InferCtxt<'tcx> {`
`68`	`67`	`.borrow_mut()`
`69`	`68`	`.int_unification_table()`
`70`	`69`	`.unify_var_var(a_id, b_id)`
`71`		`- .map_err(\|e\| int_unification_error(a_is_expected, e))?;`
	`70`	`+ .map_err(\|e\| int_unification_error(true, e))?;`
`72`	`71`	`Ok(a)`
`73`	`72`	`}`
`74`	`73`	`(&ty::Infer(ty::IntVar(v_id)), &ty::Int(v)) => {`
`75`		`- self.unify_integral_variable(a_is_expected, v_id, IntType(v))`
	`74`	`+ self.unify_integral_variable(true, v_id, IntType(v))`
`76`	`75`	`}`
`77`	`76`	`(&ty::Int(v), &ty::Infer(ty::IntVar(v_id))) => {`
`78`		`- self.unify_integral_variable(!a_is_expected, v_id, IntType(v))`
	`77`	`+ self.unify_integral_variable(!true, v_id, IntType(v))`
`79`	`78`	`}`
`80`	`79`	`(&ty::Infer(ty::IntVar(v_id)), &ty::Uint(v)) => {`
`81`		`- self.unify_integral_variable(a_is_expected, v_id, UintType(v))`
	`80`	`+ self.unify_integral_variable(true, v_id, UintType(v))`
`82`	`81`	`}`
`83`	`82`	`(&ty::Uint(v), &ty::Infer(ty::IntVar(v_id))) => {`
`84`		`- self.unify_integral_variable(!a_is_expected, v_id, UintType(v))`
	`83`	`+ self.unify_integral_variable(!true, v_id, UintType(v))`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`// Relate floating-point variables to other types`
`@@ -90,14 +89,14 @@ impl<'tcx> InferCtxt<'tcx> {`
`90`	`89`	`.borrow_mut()`
`91`	`90`	`.float_unification_table()`
`92`	`91`	`.unify_var_var(a_id, b_id)`
`93`		`- .map_err(\|e\| float_unification_error(a_is_expected, e))?;`
	`92`	`+ .map_err(\|e\| float_unification_error(true, e))?;`
`94`	`93`	`Ok(a)`
`95`	`94`	`}`
`96`	`95`	`(&ty::Infer(ty::FloatVar(v_id)), &ty::Float(v)) => {`
`97`		`- self.unify_float_variable(a_is_expected, v_id, v)`
	`96`	`+ self.unify_float_variable(true, v_id, v)`
`98`	`97`	`}`
`99`	`98`	`(&ty::Float(v), &ty::Infer(ty::FloatVar(v_id))) => {`
`100`		`- self.unify_float_variable(!a_is_expected, v_id, v)`
	`99`	`+ self.unify_float_variable(!true, v_id, v)`
`101`	`100`	`}`
`102`	`101`
`103`	`102`	// We don't expect `TyVar` or `Fresh*` vars at this point with lazy norm.
`@@ -130,7 +129,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`130`	`129`
`131`	`130`	`// All other cases of inference are errors`
`132`	`131`	`(&ty::Infer(_), _) \| (_, &ty::Infer(_)) => {`
`133`		`- Err(TypeError::Sorts(ty::relate::expected_found(relation, a, b)))`
	`132`	`+ Err(TypeError::Sorts(ty::relate::expected_found(a, b)))`
`134`	`133`	`}`
`135`	`134`
`136`	`135`	`// During coherence, opaque types should be treated as possibly`
`@@ -228,12 +227,12 @@ impl<'tcx> InferCtxt<'tcx> {`
`228`	`227`	`}`
`229`	`228`
`230`	`229`	`(ty::ConstKind::Infer(InferConst::Var(vid)), _) => {`
`231`		`- self.instantiate_const_var(relation, relation.a_is_expected(), vid, b)?;`
	`230`	`+ self.instantiate_const_var(relation, true, vid, b)?;`
`232`	`231`	`Ok(b)`
`233`	`232`	`}`
`234`	`233`
`235`	`234`	`(_, ty::ConstKind::Infer(InferConst::Var(vid))) => {`
`236`		`- self.instantiate_const_var(relation, !relation.a_is_expected(), vid, a)?;`
	`235`	`+ self.instantiate_const_var(relation, false, vid, a)?;`
`237`	`236`	`Ok(a)`
`238`	`237`	`}`
`239`	`238`
`@@ -250,8 +249,6 @@ impl<'tcx> InferCtxt<'tcx> {`
`250`	`249`	`{`
`251`	`250`	`match relation.structurally_relate_aliases() {`
`252`	`251`	`StructurallyRelateAliases::No => {`
`253`		`- let (a, b) = if relation.a_is_expected() { (a, b) } else { (b, a) };`
`254`		`-`
`255`	`252`	`relation.register_predicates([if self.next_trait_solver() {`
`256`	`253`	`ty::PredicateKind::AliasRelate(`
`257`	`254`	`a.into(),`
Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,7 @@ where`
`116`	`116`	`&& !this.infcx().next_trait_solver() =>`
`117`	`117`	`{`
`118`	`118`	`this.register_obligations(`
`119`		`- infcx`
`120`		`- .handle_opaque_type(a, b, this.a_is_expected(), this.cause(), this.param_env())?`
`121`		`- .obligations,`
	`119`	`+ infcx.handle_opaque_type(a, b, this.cause(), this.param_env())?.obligations,`
`122`	`120`	`);`
`123`	`121`	`Ok(a)`
`124`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,10 +35,6 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`35`	`35`	`self.fields.infcx.tcx`
`36`	`36`	`}`
`37`	`37`
`38`		`- fn a_is_expected(&self) -> bool {`
`39`		`- true`
`40`		`- }`
`41`		`-`
`42`	`38`	`fn relate_with_variance<T: Relate<'tcx>>(`
`43`	`39`	`&mut self,`
`44`	`40`	`variance: ty::Variance,`
`@@ -139,7 +135,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`139`	`135`	`{`
`140`	`136`	`self.fields.obligations.extend(`
`141`	`137`	`infcx`
`142`		`- .handle_opaque_type(a, b, true, &self.fields.trace.cause, self.param_env())?`
	`138`	`+ .handle_opaque_type(a, b, &self.fields.trace.cause, self.param_env())?`
`143`	`139`	`.obligations,`
`144`	`140`	`);`
`145`	`141`	`}`