Skip to content

Commit 04e2262

Browse files
compiler-errorscompiler-errors
committed
Remove a_is_expected from combine relations
1 parent 61daee6 commit 04e2262

File tree

9 files changed

+74
-134
lines changed

9 files changed

+74
-134
lines changed

‎compiler/rustc_borrowck/src/type_check/relate_tys.rs

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,6 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
120120
fn relate_opaques(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
121121
let infcx = self.type_checker.infcx;
122122
debug_assert!(!infcx.next_trait_solver());
123-
let (a, b) = if self.a_is_expected() { (a, b) } else { (b, a) };
124123
// `handle_opaque_type` cannot handle subtyping, so to support subtyping
125124
// we instead eagerly generalize here. This is a bit of a mess but will go
126125
// away once we're using the new solver.

‎compiler/rustc_infer/src/infer/at.rs

Lines changed: 29 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,6 @@ pub struct At<'a, 'tcx> {
4949

5050
pub struct Trace<'a, 'tcx> {
5151
at: At<'a, 'tcx>,
52-
a_is_expected: bool,
5352
trace: TypeTrace<'tcx>,
5453
}
5554

@@ -105,23 +104,6 @@ pub trait ToTrace<'tcx>: Relate<'tcx> + Copy {
105104
}
106105

107106
impl<'a, 'tcx> At<'a, 'tcx> {
108-
/// Makes `a <: b`, where `a` may or may not be expected.
109-
///
110-
/// See [`At::trace_exp`] and [`Trace::sub`] for a version of
111-
/// this method that only requires `T: Relate<'tcx>`
112-
pub fn sub_exp<T>(
113-
self,
114-
define_opaque_types: DefineOpaqueTypes,
115-
a_is_expected: bool,
116-
a: T,
117-
b: T,
118-
) -> InferResult<'tcx, ()>
119-
where
120-
T: ToTrace<'tcx>,
121-
{
122-
self.trace_exp(a_is_expected, a, b).sub(define_opaque_types, a, b)
123-
}
124-
125107
/// Makes `actual <: expected`. For example, if type-checking a
126108
/// call like `foo(x)`, where `foo: fn(i32)`, you might have
127109
/// `sup(i32, x)`, since the "expected" type is the type that
@@ -138,7 +120,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
138120
where
139121
T: ToTrace<'tcx>,
140122
{
141-
self.sub_exp(define_opaque_types, false, actual, expected)
123+
self.trace(expected, actual).sup(define_opaque_types, expected, actual)
142124
}
143125

144126
/// Makes `expected <: actual`.
@@ -154,24 +136,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
154136
where
155137
T: ToTrace<'tcx>,
156138
{
157-
self.sub_exp(define_opaque_types, true, expected, actual)
158-
}
159-
160-
/// Makes `expected <: actual`.
161-
///
162-
/// See [`At::trace_exp`] and [`Trace::eq`] for a version of
163-
/// this method that only requires `T: Relate<'tcx>`
164-
pub fn eq_exp<T>(
165-
self,
166-
define_opaque_types: DefineOpaqueTypes,
167-
a_is_expected: bool,
168-
a: T,
169-
b: T,
170-
) -> InferResult<'tcx, ()>
171-
where
172-
T: ToTrace<'tcx>,
173-
{
174-
self.trace_exp(a_is_expected, a, b).eq(define_opaque_types, a, b)
139+
self.trace(expected, actual).sub(define_opaque_types, expected, actual)
175140
}
176141

177142
/// Makes `expected <: actual`.
@@ -260,48 +225,50 @@ impl<'a, 'tcx> At<'a, 'tcx> {
260225
where
261226
T: ToTrace<'tcx>,
262227
{
263-
self.trace_exp(true, expected, actual)
228+
let trace = ToTrace::to_trace(self.cause, true, expected, actual);
229+
Trace { at: self, trace }
264230
}
231+
}
265232

266-
/// Like `trace`, but the expected value is determined by the
267-
/// boolean argument (if true, then the first argument `a` is the
268-
/// "expected" value).
269-
pub fn trace_exp<T>(self, a_is_expected: bool, a: T, b: T) -> Trace<'a, 'tcx>
233+
impl<'a, 'tcx> Trace<'a, 'tcx> {
234+
/// Makes `a <: b`.
235+
#[instrument(skip(self), level = "debug")]
236+
pub fn sub<T>(self, define_opaque_types: DefineOpaqueTypes, a: T, b: T) -> InferResult<'tcx, ()>
270237
where
271-
T: ToTrace<'tcx>,
238+
T: Relate<'tcx>,
272239
{
273-
let trace = ToTrace::to_trace(self.cause, a_is_expected, a, b);
274-
Trace { at: self, trace, a_is_expected }
240+
let Trace { at, trace } = self;
241+
let mut fields = at.infcx.combine_fields(trace, at.param_env, define_opaque_types);
242+
fields
243+
.sub()
244+
.relate(a, b)
245+
.map(move |_| InferOk { value: (), obligations: fields.obligations })
275246
}
276-
}
277247

278-
impl<'a, 'tcx> Trace<'a, 'tcx> {
279-
/// Makes `a <: b` where `a` may or may not be expected (if
280-
/// `a_is_expected` is true, then `a` is expected).
248+
/// Makes `a :> b`.
281249
#[instrument(skip(self), level = "debug")]
282-
pub fn sub<T>(self, define_opaque_types: DefineOpaqueTypes, a: T, b: T) -> InferResult<'tcx, ()>
250+
pub fn sup<T>(self, define_opaque_types: DefineOpaqueTypes, a: T, b: T) -> InferResult<'tcx, ()>
283251
where
284252
T: Relate<'tcx>,
285253
{
286-
let Trace { at, trace, a_is_expected } = self;
254+
let Trace { at, trace } = self;
287255
let mut fields = at.infcx.combine_fields(trace, at.param_env, define_opaque_types);
288256
fields
289-
.sub(a_is_expected)
257+
.sup()
290258
.relate(a, b)
291259
.map(move |_| InferOk { value: (), obligations: fields.obligations })
292260
}
293261

294-
/// Makes `a == b`; the expectation is set by the call to
295-
/// `trace()`.
262+
/// Makes `a == b`.
296263
#[instrument(skip(self), level = "debug")]
297264
pub fn eq<T>(self, define_opaque_types: DefineOpaqueTypes, a: T, b: T) -> InferResult<'tcx, ()>
298265
where
299266
T: Relate<'tcx>,
300267
{
301-
let Trace { at, trace, a_is_expected } = self;
268+
let Trace { at, trace } = self;
302269
let mut fields = at.infcx.combine_fields(trace, at.param_env, define_opaque_types);
303270
fields
304-
.equate(StructurallyRelateAliases::No, a_is_expected)
271+
.equate(StructurallyRelateAliases::No)
305272
.relate(a, b)
306273
.map(move |_| InferOk { value: (), obligations: fields.obligations })
307274
}
@@ -313,11 +280,11 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
313280
where
314281
T: Relate<'tcx>,
315282
{
316-
let Trace { at, trace, a_is_expected } = self;
283+
let Trace { at, trace } = self;
317284
debug_assert!(at.infcx.next_trait_solver());
318285
let mut fields = at.infcx.combine_fields(trace, at.param_env, DefineOpaqueTypes::No);
319286
fields
320-
.equate(StructurallyRelateAliases::Yes, a_is_expected)
287+
.equate(StructurallyRelateAliases::Yes)
321288
.relate(a, b)
322289
.map(move |_| InferOk { value: (), obligations: fields.obligations })
323290
}
@@ -327,10 +294,10 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
327294
where
328295
T: Relate<'tcx>,
329296
{
330-
let Trace { at, trace, a_is_expected } = self;
297+
let Trace { at, trace } = self;
331298
let mut fields = at.infcx.combine_fields(trace, at.param_env, define_opaque_types);
332299
fields
333-
.lub(a_is_expected)
300+
.lub()
334301
.relate(a, b)
335302
.map(move |t| InferOk { value: t, obligations: fields.obligations })
336303
}
@@ -340,10 +307,10 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
340307
where
341308
T: Relate<'tcx>,
342309
{
343-
let Trace { at, trace, a_is_expected } = self;
310+
let Trace { at, trace } = self;
344311
let mut fields = at.infcx.combine_fields(trace, at.param_env, define_opaque_types);
345312
fields
346-
.glb(a_is_expected)
313+
.glb()
347314
.relate(a, b)
348315
.map(move |t| InferOk { value: t, obligations: fields.obligations })
349316
}

‎compiler/rustc_infer/src/infer/opaque_types.rs

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -522,13 +522,7 @@ impl<'tcx> InferCtxt<'tcx> {
522522
) -> InferResult<'tcx, ()> {
523523
let mut obligations = Vec::new();
524524

525-
self.insert_hidden_type(
526-
opaque_type_key,
527-
&cause,
528-
param_env,
529-
hidden_ty,
530-
&mut obligations,
531-
)?;
525+
self.insert_hidden_type(opaque_type_key, &cause, param_env, hidden_ty, &mut obligations)?;
532526

533527
self.add_item_bounds_for_hidden_type(
534528
opaque_type_key.def_id.to_def_id(),

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

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -321,21 +321,24 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
321321
pub fn equate<'a>(
322322
&'a mut self,
323323
structurally_relate_aliases: StructurallyRelateAliases,
324-
a_is_expected: bool,
325324
) -> TypeRelating<'a, 'infcx, 'tcx> {
326-
TypeRelating::new(self, a_is_expected, structurally_relate_aliases, ty::Invariant)
325+
TypeRelating::new(self, structurally_relate_aliases, ty::Invariant)
327326
}
328327

329-
pub fn sub<'a>(&'a mut self, a_is_expected: bool) -> TypeRelating<'a, 'infcx, 'tcx> {
330-
TypeRelating::new(self, a_is_expected, StructurallyRelateAliases::No, ty::Covariant)
328+
pub fn sub<'a>(&'a mut self) -> TypeRelating<'a, 'infcx, 'tcx> {
329+
TypeRelating::new(self, StructurallyRelateAliases::No, ty::Covariant)
331330
}
332331

333-
pub fn lub<'a>(&'a mut self, a_is_expected: bool) -> Lub<'a, 'infcx, 'tcx> {
334-
Lub::new(self, a_is_expected)
332+
pub fn sup<'a>(&'a mut self) -> TypeRelating<'a, 'infcx, 'tcx> {
333+
TypeRelating::new(self, StructurallyRelateAliases::No, ty::Contravariant)
335334
}
336335

337-
pub fn glb<'a>(&'a mut self, a_is_expected: bool) -> Glb<'a, 'infcx, 'tcx> {
338-
Glb::new(self, a_is_expected)
336+
pub fn lub<'a>(&'a mut self) -> Lub<'a, 'infcx, 'tcx> {
337+
Lub::new(self)
338+
}
339+
340+
pub fn glb<'a>(&'a mut self) -> Glb<'a, 'infcx, 'tcx> {
341+
Glb::new(self)
339342
}
340343

341344
pub fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>) {

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

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -13,15 +13,11 @@ use crate::traits::{ObligationCause, PredicateObligations};
1313
/// "Greatest lower bound" (common subtype)
1414
pub struct Glb<'combine, 'infcx, 'tcx> {
1515
fields: &'combine mut CombineFields<'infcx, 'tcx>,
16-
a_is_expected: bool,
1716
}
1817

1918
impl<'combine, 'infcx, 'tcx> Glb<'combine, 'infcx, 'tcx> {
20-
pub fn new(
21-
fields: &'combine mut CombineFields<'infcx, 'tcx>,
22-
a_is_expected: bool,
23-
) -> Glb<'combine, 'infcx, 'tcx> {
24-
Glb { fields, a_is_expected }
19+
pub fn new(fields: &'combine mut CombineFields<'infcx, 'tcx>) -> Glb<'combine, 'infcx, 'tcx> {
20+
Glb { fields }
2521
}
2622
}
2723

@@ -35,7 +31,7 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
3531
}
3632

3733
fn a_is_expected(&self) -> bool {
38-
self.a_is_expected
34+
true
3935
}
4036

4137
fn relate_with_variance<T: Relate<'tcx>>(
@@ -46,13 +42,11 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
4642
b: T,
4743
) -> RelateResult<'tcx, T> {
4844
match variance {
49-
ty::Invariant => {
50-
self.fields.equate(StructurallyRelateAliases::No, self.a_is_expected).relate(a, b)
51-
}
45+
ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
5246
ty::Covariant => self.relate(a, b),
5347
// FIXME(#41044) -- not correct, need test
5448
ty::Bivariant => Ok(a),
55-
ty::Contravariant => self.fields.lub(self.a_is_expected).relate(a, b),
49+
ty::Contravariant => self.fields.lub().relate(a, b),
5650
}
5751
}
5852

@@ -126,7 +120,7 @@ impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx,
126120
}
127121

128122
fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
129-
let mut sub = self.fields.sub(self.a_is_expected);
123+
let mut sub = self.fields.sub();
130124
sub.relate(v, a)?;
131125
sub.relate(v, b)?;
132126
Ok(())

‎compiler/rustc_infer/src/infer/relate/higher_ranked.rs

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,13 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> {
4949
debug!("b_prime={:?}", sup_prime);
5050

5151
// Compare types now that bound regions have been replaced.
52-
let result = self.sub(sub_is_expected).relate(sub_prime, sup_prime);
52+
// Reorder the inputs so that the expected is passed first.
53+
let result = if sub_is_expected {
54+
self.sub().relate(sub_prime, sup_prime)
55+
} else {
56+
self.sup().relate(sup_prime, sub_prime)
57+
};
58+
5359
if result.is_ok() {
5460
debug!("OK result={result:?}");
5561
}

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

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -13,15 +13,11 @@ use rustc_span::Span;
1313
/// "Least upper bound" (common supertype)
1414
pub struct Lub<'combine, 'infcx, 'tcx> {
1515
fields: &'combine mut CombineFields<'infcx, 'tcx>,
16-
a_is_expected: bool,
1716
}
1817

1918
impl<'combine, 'infcx, 'tcx> Lub<'combine, 'infcx, 'tcx> {
20-
pub fn new(
21-
fields: &'combine mut CombineFields<'infcx, 'tcx>,
22-
a_is_expected: bool,
23-
) -> Lub<'combine, 'infcx, 'tcx> {
24-
Lub { fields, a_is_expected }
19+
pub fn new(fields: &'combine mut CombineFields<'infcx, 'tcx>) -> Lub<'combine, 'infcx, 'tcx> {
20+
Lub { fields }
2521
}
2622
}
2723

@@ -35,7 +31,7 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
3531
}
3632

3733
fn a_is_expected(&self) -> bool {
38-
self.a_is_expected
34+
true
3935
}
4036

4137
fn relate_with_variance<T: Relate<'tcx>>(
@@ -46,13 +42,11 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
4642
b: T,
4743
) -> RelateResult<'tcx, T> {
4844
match variance {
49-
ty::Invariant => {
50-
self.fields.equate(StructurallyRelateAliases::No, self.a_is_expected).relate(a, b)
51-
}
45+
ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
5246
ty::Covariant => self.relate(a, b),
5347
// FIXME(#41044) -- not correct, need test
5448
ty::Bivariant => Ok(a),
55-
ty::Contravariant => self.fields.glb(self.a_is_expected).relate(a, b),
49+
ty::Contravariant => self.fields.glb().relate(a, b),
5650
}
5751
}
5852

@@ -126,7 +120,7 @@ impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Lub<'combine, 'infcx,
126120
}
127121

128122
fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
129-
let mut sub = self.fields.sub(self.a_is_expected);
123+
let mut sub = self.fields.sub();
130124
sub.relate(a, v)?;
131125
sub.relate(b, v)?;
132126
Ok(())

0 commit comments

Comments
 (0)