Skip to content

Commit 7b91b20

Browse files
arielb1arielb1
committed
lift TypeFoldable over Result
1 parent c0086b9 commit 7b91b20

File tree

30 files changed

+721
-552
lines changed

30 files changed

+721
-552
lines changed

‎src/librustc/infer/canonical/canonicalizer.rs

Lines changed: 19 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -284,11 +284,13 @@ struct Canonicalizer<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
284284
}
285285

286286
impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx> {
287+
type Error = !;
288+
287289
fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> {
288290
self.tcx
289291
}
290292

291-
fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
293+
fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> Result<ty::Binder<T>, !>
292294
where T: TypeFoldable<'tcx>
293295
{
294296
self.binder_index.shift_in(1);
@@ -297,8 +299,8 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>
297299
t
298300
}
299301

300-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
301-
match *r {
302+
fn fold_region(&mut self, r: ty::Region<'tcx>) -> Result<ty::Region<'tcx>, !> {
303+
Ok(match *r {
302304
ty::ReLateBound(index, ..) => {
303305
if index >= self.binder_index {
304306
bug!("escaping late bound region during canonicalization")
@@ -333,10 +335,10 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>
333335
ty::ReClosureBound(..) => {
334336
bug!("closure bound region encountered during canonicalization")
335337
}
336-
}
338+
})
337339
}
338340

339-
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
341+
fn fold_ty(&mut self, t: Ty<'tcx>) -> Result<Ty<'tcx>, !> {
340342
match t.sty {
341343
ty::Infer(ty::TyVar(vid)) => {
342344
debug!("canonical: type var found with vid {:?}", vid);
@@ -354,48 +356,48 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>
354356
// FIXME: perf problem described in #55921.
355357
ui = ty::UniverseIndex::ROOT;
356358
}
357-
self.canonicalize_ty_var(
359+
Ok(self.canonicalize_ty_var(
358360
CanonicalVarInfo {
359361
kind: CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui))
360362
},
361363
t
362-
)
364+
))
363365
}
364366
}
365367
}
366368

367-
ty::Infer(ty::IntVar(_)) => self.canonicalize_ty_var(
369+
ty::Infer(ty::IntVar(_)) => Ok(self.canonicalize_ty_var(
368370
CanonicalVarInfo {
369371
kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Int)
370372
},
371373
t
372-
),
374+
)),
373375

374-
ty::Infer(ty::FloatVar(_)) => self.canonicalize_ty_var(
376+
ty::Infer(ty::FloatVar(_)) => Ok(self.canonicalize_ty_var(
375377
CanonicalVarInfo {
376378
kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Float)
377379
},
378380
t
379-
),
381+
)),
380382

381383
ty::Infer(ty::FreshTy(_))
382384
| ty::Infer(ty::FreshIntTy(_))
383385
| ty::Infer(ty::FreshFloatTy(_)) => {
384386
bug!("encountered a fresh type during canonicalization")
385387
}
386388

387-
ty::Placeholder(placeholder) => self.canonicalize_ty_var(
389+
ty::Placeholder(placeholder) => Ok(self.canonicalize_ty_var(
388390
CanonicalVarInfo {
389391
kind: CanonicalVarKind::PlaceholderTy(placeholder)
390392
},
391393
t
392-
),
394+
)),
393395

394396
ty::Bound(debruijn, _) => {
395397
if debruijn >= self.binder_index {
396398
bug!("escaping bound type during canonicalization")
397399
} else {
398-
t
400+
Ok(t)
399401
}
400402
}
401403

@@ -427,7 +429,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>
427429
if t.flags.intersects(self.needs_canonical_flags) {
428430
t.super_fold_with(self)
429431
} else {
430-
t
432+
Ok(t)
431433
}
432434
}
433435
}
@@ -485,7 +487,7 @@ impl<'cx, 'gcx, 'tcx> Canonicalizer<'cx, 'gcx, 'tcx> {
485487
indices: FxHashMap::default(),
486488
binder_index: ty::INNERMOST,
487489
};
488-
let out_value = value.fold_with(&mut canonicalizer);
490+
let Ok(out_value) = value.fold_with(&mut canonicalizer);
489491

490492
// Once we have canonicalized `out_value`, it should not
491493
// contain anything that ties it to this inference context
@@ -627,7 +629,7 @@ impl<'cx, 'gcx, 'tcx> Canonicalizer<'cx, 'gcx, 'tcx> {
627629
let infcx = self.infcx.expect("encountered ty-var without infcx");
628630
let bound_to = infcx.shallow_resolve(ty_var);
629631
if bound_to != ty_var {
630-
self.fold_ty(bound_to)
632+
self.fold_ty(bound_to).unwrap_or_else(|e: !| e)
631633
} else {
632634
let var = self.canonical_var(info, ty_var.into());
633635
self.tcx().mk_ty(ty::Bound(self.binder_index, var.into()))

‎src/librustc/infer/freshen.rs

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ impl<'a, 'gcx, 'tcx> TypeFreshener<'a, 'gcx, 'tcx> {
6464
F: FnOnce(u32) -> ty::InferTy,
6565
{
6666
if let Some(ty) = opt_ty {
67-
return ty.fold_with(self);
67+
return ty.fold_with(self).unwrap_or_else(|e: !| e);
6868
}
6969

7070
match self.freshen_map.entry(key) {
@@ -81,12 +81,14 @@ impl<'a, 'gcx, 'tcx> TypeFreshener<'a, 'gcx, 'tcx> {
8181
}
8282

8383
impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
84+
type Error = !;
85+
8486
fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> {
8587
self.infcx.tcx
8688
}
8789

88-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
89-
match *r {
90+
fn fold_region(&mut self, r: ty::Region<'tcx>) -> Result<ty::Region<'tcx>, !> {
91+
Ok(match *r {
9092
ty::ReLateBound(..) => {
9193
// leave bound regions alone
9294
r
@@ -110,18 +112,18 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
110112
r,
111113
);
112114
}
113-
}
115+
})
114116
}
115117

116-
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
118+
fn fold_ty(&mut self, t: Ty<'tcx>) -> Result<Ty<'tcx>, !> {
117119
if !t.needs_infer() && !t.has_erasable_regions() &&
118120
!(t.has_closure_types() && self.infcx.in_progress_tables.is_some()) {
119-
return t;
121+
return Ok(t);
120122
}
121123

122124
let tcx = self.infcx.tcx;
123125

124-
match t.sty {
126+
Ok(match t.sty {
125127
ty::Infer(ty::TyVar(v)) => {
126128
let opt_ty = self.infcx.type_variables.borrow_mut().probe(v).known();
127129
self.freshen(
@@ -185,11 +187,11 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
185187
ty::Closure(..) |
186188
ty::GeneratorWitness(..) |
187189
ty::Opaque(..) => {
188-
t.super_fold_with(self)
190+
t.super_fold_with(self)?
189191
}
190192

191193
ty::Placeholder(..) |
192194
ty::Bound(..) => bug!("unexpected type {:?}", t),
193-
}
195+
})
194196
}
195197
}

‎src/librustc/infer/fudge.rs

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
9595
origin,
9696
};
9797

98-
Ok(value.fold_with(&mut fudger))
98+
value.fold_with(&mut fudger).map_err(|e| e)
9999
}
100100
}
101101

@@ -107,11 +107,13 @@ pub struct RegionFudger<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
107107
}
108108

109109
impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for RegionFudger<'a, 'gcx, 'tcx> {
110+
type Error = !;
111+
110112
fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> {
111113
self.infcx.tcx
112114
}
113115

114-
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
116+
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, !> {
115117
match ty.sty {
116118
ty::Infer(ty::InferTy::TyVar(vid)) => {
117119
match self.type_variables.get(&vid) {
@@ -124,29 +126,29 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for RegionFudger<'a, 'gcx, 'tcx> {
124126
debug_assert!(self.infcx.type_variables.borrow_mut()
125127
.probe(vid)
126128
.is_unknown());
127-
ty
129+
Ok(ty)
128130
}
129131

130132
Some(&origin) => {
131133
// This variable was created during the
132134
// fudging. Recreate it with a fresh variable
133135
// here.
134-
self.infcx.next_ty_var(origin)
136+
Ok(self.infcx.next_ty_var(origin))
135137
}
136138
}
137139
}
138140
_ => ty.super_fold_with(self),
139141
}
140142
}
141143

142-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
143-
match *r {
144+
fn fold_region(&mut self, r: ty::Region<'tcx>) -> Result<ty::Region<'tcx>, !> {
145+
Ok(match *r {
144146
ty::ReVar(v) if self.region_vars.contains(&v) => {
145147
self.infcx.next_region_var(self.origin.clone())
146148
}
147149
_ => {
148150
r
149151
}
150-
}
152+
})
151153
}
152154
}

‎src/librustc/infer/mod.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -604,7 +604,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
604604
}
605605

606606
pub fn freshen<T: TypeFoldable<'tcx>>(&self, t: T) -> T {
607-
t.fold_with(&mut self.freshener())
607+
t.fold_with(&mut self.freshener()).unwrap_or_else(|e: !| e)
608608
}
609609

610610
pub fn type_var_diverges(&'a self, ty: Ty<'_>) -> bool {
@@ -1298,7 +1298,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
12981298
return value.clone(); // avoid duplicated subst-folding
12991299
}
13001300
let mut r = resolve::OpportunisticTypeResolver::new(self);
1301-
value.fold_with(&mut r)
1301+
value.fold_with(&mut r).unwrap_or_else(|e: !| e)
13021302
}
13031303

13041304
/// Returns `true` if `T` contains unresolved type variables. In the
@@ -1311,7 +1311,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
13111311
T: TypeFoldable<'tcx>,
13121312
{
13131313
let mut r = resolve::UnresolvedTypeFinder::new(self);
1314-
value.visit_with(&mut r)
1314+
value.visit_with(&mut r).is_err()
13151315
}
13161316

13171317
pub fn fully_resolve<T: TypeFoldable<'tcx>>(&self, value: &T) -> FixupResult<T> {

‎src/librustc/infer/nll_relate/mod.rs

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ where
196196
}
197197
};
198198

199-
value.skip_binder().visit_with(&mut ScopeInstantiator {
199+
let Ok(_) = value.skip_binder().visit_with(&mut ScopeInstantiator {
200200
next_region: &mut next_region,
201201
target_index: ty::INNERMOST,
202202
bound_region_scope: &mut scope,
@@ -604,15 +604,17 @@ struct ScopeInstantiator<'me, 'tcx: 'me> {
604604
}
605605

606606
impl<'me, 'tcx> TypeVisitor<'tcx> for ScopeInstantiator<'me, 'tcx> {
607-
fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &ty::Binder<T>) -> bool {
607+
type Error = !;
608+
609+
fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &ty::Binder<T>) -> Result<(), !> {
608610
self.target_index.shift_in(1);
609-
t.super_visit_with(self);
611+
t.super_visit_with(self)?;
610612
self.target_index.shift_out(1);
611613

612-
false
614+
Ok(())
613615
}
614616

615-
fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
617+
fn visit_region(&mut self, r: ty::Region<'tcx>) -> Result<(), !> {
616618
let ScopeInstantiator {
617619
bound_region_scope,
618620
next_region,
@@ -630,7 +632,7 @@ impl<'me, 'tcx> TypeVisitor<'tcx> for ScopeInstantiator<'me, 'tcx> {
630632
_ => {}
631633
}
632634

633-
false
635+
Ok(())
634636
}
635637
}
636638

‎src/librustc/infer/opaque_types/mod.rs

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -448,7 +448,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
448448
// Convert the type from the function into a type valid outside
449449
// the function, by replacing invalid regions with 'static,
450450
// after producing an error for each of them.
451-
let definition_ty =
451+
let Ok(definition_ty) =
452452
instantiated_ty.fold_with(&mut ReverseMapper::new(
453453
self.tcx,
454454
self.is_tainted_by_errors(),
@@ -506,23 +506,25 @@ impl<'cx, 'gcx, 'tcx> ReverseMapper<'cx, 'gcx, 'tcx> {
506506
fn fold_kind_mapping_missing_regions_to_empty(&mut self, kind: Kind<'tcx>) -> Kind<'tcx> {
507507
assert!(!self.map_missing_regions_to_empty);
508508
self.map_missing_regions_to_empty = true;
509-
let kind = kind.fold_with(self);
509+
let Ok(kind) = kind.fold_with(self);
510510
self.map_missing_regions_to_empty = false;
511511
kind
512512
}
513513

514514
fn fold_kind_normally(&mut self, kind: Kind<'tcx>) -> Kind<'tcx> {
515515
assert!(!self.map_missing_regions_to_empty);
516-
kind.fold_with(self)
516+
kind.fold_with(self).unwrap_or_else(|e: !| e)
517517
}
518518
}
519519

520520
impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ReverseMapper<'cx, 'gcx, 'tcx> {
521+
type Error = !;
522+
521523
fn tcx(&self) -> TyCtxt<'_, 'gcx, 'tcx> {
522524
self.tcx
523525
}
524526

525-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
527+
fn fold_region(&mut self, r: ty::Region<'tcx>) -> Result<ty::Region<'tcx>, !> {
526528
match r {
527529
// ignore bound regions that appear in the type (e.g., this
528530
// would ignore `'r` in a type like `for<'r> fn(&'r u32)`.
@@ -533,13 +535,13 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ReverseMapper<'cx, 'gcx, 'tcx>
533535

534536
// ignore `ReScope`, as that can appear anywhere
535537
// See `src/test/run-pass/issue-49556.rs` for example.
536-
ty::ReScope(..) => return r,
538+
ty::ReScope(..) => return Ok(r),
537539

538540
_ => { }
539541
}
540542

541543
match self.map.get(&r.into()).map(|k| k.unpack()) {
542-
Some(UnpackedKind::Lifetime(r1)) => r1,
544+
Some(UnpackedKind::Lifetime(r1)) => Ok(r1),
543545
Some(u) => panic!("region mapped to unexpected kind: {:?}", u),
544546
None => {
545547
if !self.map_missing_regions_to_empty && !self.tainted_by_errors {
@@ -576,12 +578,12 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ReverseMapper<'cx, 'gcx, 'tcx>
576578
err.emit();
577579
}
578580
}
579-
self.tcx.types.re_empty
581+
Ok(self.tcx.types.re_empty)
580582
},
581583
}
582584
}
583585

584-
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
586+
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, !> {
585587
match ty.sty {
586588
ty::Closure(def_id, substs) => {
587589
// I am a horrible monster and I pray for death. When
@@ -621,7 +623,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ReverseMapper<'cx, 'gcx, 'tcx>
621623
},
622624
));
623625

624-
self.tcx.mk_closure(def_id, ty::ClosureSubsts { substs })
626+
Ok(self.tcx.mk_closure(def_id, ty::ClosureSubsts { substs }))
625627
}
626628

627629
_ => ty.super_fold_with(self),
@@ -733,7 +735,7 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
733735

734736
ty
735737
},
736-
})
738+
}).unwrap_or_else(|e: !| e)
737739
}
738740

739741
fn fold_opaque_ty(

0 commit comments

Comments
 (0)