Skip to content

Commit 994bc59

Browse files
eggyaleggyal
committed
Convert non-failing fallible folders to infallible
1 parent 5b9c408 commit 994bc59

File tree

8 files changed

+183
-211
lines changed

8 files changed

+183
-211
lines changed

‎chalk-engine/src/normalize_deep.rs

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,11 @@
1+
use chalk_derive::FallibleTypeFolder;
12
use chalk_ir::fold::shift::Shift;
2-
use chalk_ir::fold::{FallibleTypeFolder, TypeFoldable};
3+
use chalk_ir::fold::{TypeFoldable, TypeFolder};
34
use chalk_ir::interner::Interner;
45
use chalk_ir::*;
56
use chalk_solve::infer::InferenceTable;
67

8+
#[derive(FallibleTypeFolder)]
79
pub(crate) struct DeepNormalizer<'table, I: Interner> {
810
table: &'table mut InferenceTable<I>,
911
interner: I,
@@ -35,64 +37,62 @@ impl<I: Interner> DeepNormalizer<'_, I> {
3537
}
3638
}
3739

38-
impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
39-
type Error = NoSolution;
40-
41-
fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<I, Error = Self::Error> {
40+
impl<I: Interner> TypeFolder<I> for DeepNormalizer<'_, I> {
41+
fn as_dyn(&mut self) -> &mut dyn TypeFolder<I> {
4242
self
4343
}
4444

45-
fn try_fold_inference_ty(
45+
fn fold_inference_ty(
4646
&mut self,
4747
var: InferenceVar,
4848
kind: TyVariableKind,
4949
_outer_binder: DebruijnIndex,
50-
) -> Fallible<Ty<I>> {
50+
) -> Ty<I> {
5151
let interner = self.interner;
5252
match self.table.probe_var(var) {
53-
Some(ty) => Ok(ty
53+
Some(ty) => ty
5454
.assert_ty_ref(interner)
5555
.clone()
56-
.try_fold_with(self, DebruijnIndex::INNERMOST)?
57-
.shifted_in(interner)), // FIXME shift
56+
.fold_with(self, DebruijnIndex::INNERMOST)
57+
.shifted_in(interner), // FIXME shift
5858
None => {
5959
// Normalize all inference vars which have been unified into a
6060
// single variable. Ena calls this the "root" variable.
61-
Ok(self.table.inference_var_root(var).to_ty(interner, kind))
61+
self.table.inference_var_root(var).to_ty(interner, kind)
6262
}
6363
}
6464
}
6565

66-
fn try_fold_inference_lifetime(
66+
fn fold_inference_lifetime(
6767
&mut self,
6868
var: InferenceVar,
6969
_outer_binder: DebruijnIndex,
70-
) -> Fallible<Lifetime<I>> {
70+
) -> Lifetime<I> {
7171
let interner = self.interner;
7272
match self.table.probe_var(var) {
73-
Some(l) => Ok(l
73+
Some(l) => l
7474
.assert_lifetime_ref(interner)
7575
.clone()
76-
.try_fold_with(self, DebruijnIndex::INNERMOST)?
77-
.shifted_in(interner)),
78-
None => Ok(var.to_lifetime(interner)), // FIXME shift
76+
.fold_with(self, DebruijnIndex::INNERMOST)
77+
.shifted_in(interner),
78+
None => var.to_lifetime(interner), // FIXME shift
7979
}
8080
}
8181

82-
fn try_fold_inference_const(
82+
fn fold_inference_const(
8383
&mut self,
8484
ty: Ty<I>,
8585
var: InferenceVar,
8686
_outer_binder: DebruijnIndex,
87-
) -> Fallible<Const<I>> {
87+
) -> Const<I> {
8888
let interner = self.interner;
8989
match self.table.probe_var(var) {
90-
Some(c) => Ok(c
90+
Some(c) => c
9191
.assert_const_ref(interner)
9292
.clone()
93-
.try_fold_with(self, DebruijnIndex::INNERMOST)?
94-
.shifted_in(interner)),
95-
None => Ok(var.to_const(interner, ty)), // FIXME shift
93+
.fold_with(self, DebruijnIndex::INNERMOST)
94+
.shifted_in(interner),
95+
None => var.to_const(interner, ty), // FIXME shift
9696
}
9797
}
9898

‎chalk-ir/src/fold/shift.rs

Lines changed: 16 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
//! Shifting of debruijn indices
22
3-
use super::TypeFoldable;
43
use crate::*;
54

65
/// Methods for converting debruijn indices to move values into or out
@@ -55,12 +54,13 @@ impl<T: TypeFoldable<I>, I: Interner> Shift<I> for T {
5554
}
5655

5756
/// A folder that adjusts debruijn indices by a certain amount.
58-
struct Shifter<I> {
57+
#[derive(FallibleTypeFolder)]
58+
struct Shifter<I: Interner> {
5959
source_binder: DebruijnIndex,
6060
interner: I,
6161
}
6262

63-
impl<I> Shifter<I> {
63+
impl<I: Interner> Shifter<I> {
6464
/// Given a free variable at `depth`, shifts that depth to `depth
6565
/// + self.adjustment`, and then wraps *that* within the internal
6666
/// set `binders`.
@@ -71,42 +71,34 @@ impl<I> Shifter<I> {
7171
}
7272
}
7373

74-
impl<I: Interner> FallibleTypeFolder<I> for Shifter<I> {
75-
type Error = NoSolution;
76-
77-
fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<I, Error = Self::Error> {
74+
impl<I: Interner> TypeFolder<I> for Shifter<I> {
75+
fn as_dyn(&mut self) -> &mut dyn TypeFolder<I> {
7876
self
7977
}
8078

81-
fn try_fold_free_var_ty(
82-
&mut self,
83-
bound_var: BoundVar,
84-
outer_binder: DebruijnIndex,
85-
) -> Fallible<Ty<I>> {
86-
Ok(TyKind::<I>::BoundVar(self.adjust(bound_var, outer_binder)).intern(self.interner()))
79+
fn fold_free_var_ty(&mut self, bound_var: BoundVar, outer_binder: DebruijnIndex) -> Ty<I> {
80+
TyKind::<I>::BoundVar(self.adjust(bound_var, outer_binder))
81+
.intern(TypeFolder::interner(self))
8782
}
8883

89-
fn try_fold_free_var_lifetime(
84+
fn fold_free_var_lifetime(
9085
&mut self,
9186
bound_var: BoundVar,
9287
outer_binder: DebruijnIndex,
93-
) -> Fallible<Lifetime<I>> {
94-
Ok(
95-
LifetimeData::<I>::BoundVar(self.adjust(bound_var, outer_binder))
96-
.intern(self.interner()),
97-
)
88+
) -> Lifetime<I> {
89+
LifetimeData::<I>::BoundVar(self.adjust(bound_var, outer_binder))
90+
.intern(TypeFolder::interner(self))
9891
}
9992

100-
fn try_fold_free_var_const(
93+
fn fold_free_var_const(
10194
&mut self,
10295
ty: Ty<I>,
10396
bound_var: BoundVar,
10497
outer_binder: DebruijnIndex,
105-
) -> Fallible<Const<I>> {
98+
) -> Const<I> {
10699
// const types don't have free variables, so we can skip folding `ty`
107-
Ok(self
108-
.adjust(bound_var, outer_binder)
109-
.to_const(self.interner(), ty))
100+
self.adjust(bound_var, outer_binder)
101+
.to_const(TypeFolder::interner(self), ty)
110102
}
111103

112104
fn interner(&self) -> I {

‎chalk-ir/src/fold/subst.rs

Lines changed: 26 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ use super::*;
22
use crate::fold::shift::Shift;
33

44
/// Substitution used during folding
5+
#[derive(FallibleTypeFolder)]
56
pub struct Subst<'s, I: Interner> {
67
/// Values to substitute. A reference to a free variable with
78
/// index `i` will be mapped to `parameters[i]` -- if `i >
@@ -25,10 +26,8 @@ impl<I: Interner> Subst<'_, I> {
2526
}
2627
}
2728

28-
impl<I: Interner> FallibleTypeFolder<I> for Subst<'_, I> {
29-
type Error = NoSolution;
30-
31-
fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<I, Error = Self::Error> {
29+
impl<I: Interner> TypeFolder<I> for Subst<'_, I> {
30+
fn as_dyn(&mut self) -> &mut dyn TypeFolder<I> {
3231
self
3332
}
3433

@@ -51,69 +50,65 @@ impl<I: Interner> FallibleTypeFolder<I> for Subst<'_, I> {
5150
/// for<A, B> { [A, u32] }
5251
/// ^ represented as `^0.0`
5352
/// ```
54-
fn try_fold_free_var_ty(
55-
&mut self,
56-
bound_var: BoundVar,
57-
outer_binder: DebruijnIndex,
58-
) -> Fallible<Ty<I>> {
53+
fn fold_free_var_ty(&mut self, bound_var: BoundVar, outer_binder: DebruijnIndex) -> Ty<I> {
5954
if let Some(index) = bound_var.index_if_innermost() {
60-
match self.parameters[index].data(self.interner()) {
61-
GenericArgData::Ty(t) => {
62-
Ok(t.clone().shifted_in_from(self.interner(), outer_binder))
63-
}
55+
match self.parameters[index].data(TypeFolder::interner(self)) {
56+
GenericArgData::Ty(t) => t
57+
.clone()
58+
.shifted_in_from(TypeFolder::interner(self), outer_binder),
6459
_ => panic!("mismatched kinds in substitution"),
6560
}
6661
} else {
67-
Ok(bound_var
62+
bound_var
6863
.shifted_out()
6964
.expect("cannot fail because this is not the innermost")
7065
.shifted_in_from(outer_binder)
71-
.to_ty(self.interner()))
66+
.to_ty(TypeFolder::interner(self))
7267
}
7368
}
7469

7570
/// see `fold_free_var_ty`
76-
fn try_fold_free_var_lifetime(
71+
fn fold_free_var_lifetime(
7772
&mut self,
7873
bound_var: BoundVar,
7974
outer_binder: DebruijnIndex,
80-
) -> Fallible<Lifetime<I>> {
75+
) -> Lifetime<I> {
8176
if let Some(index) = bound_var.index_if_innermost() {
82-
match self.parameters[index].data(self.interner()) {
83-
GenericArgData::Lifetime(l) => {
84-
Ok(l.clone().shifted_in_from(self.interner(), outer_binder))
85-
}
77+
match self.parameters[index].data(TypeFolder::interner(self)) {
78+
GenericArgData::Lifetime(l) => l
79+
.clone()
80+
.shifted_in_from(TypeFolder::interner(self), outer_binder),
8681
_ => panic!("mismatched kinds in substitution"),
8782
}
8883
} else {
89-
Ok(bound_var
84+
bound_var
9085
.shifted_out()
9186
.unwrap()
9287
.shifted_in_from(outer_binder)
93-
.to_lifetime(self.interner()))
88+
.to_lifetime(TypeFolder::interner(self))
9489
}
9590
}
9691

9792
/// see `fold_free_var_ty`
98-
fn try_fold_free_var_const(
93+
fn fold_free_var_const(
9994
&mut self,
10095
ty: Ty<I>,
10196
bound_var: BoundVar,
10297
outer_binder: DebruijnIndex,
103-
) -> Fallible<Const<I>> {
98+
) -> Const<I> {
10499
if let Some(index) = bound_var.index_if_innermost() {
105-
match self.parameters[index].data(self.interner()) {
106-
GenericArgData::Const(c) => {
107-
Ok(c.clone().shifted_in_from(self.interner(), outer_binder))
108-
}
100+
match self.parameters[index].data(TypeFolder::interner(self)) {
101+
GenericArgData::Const(c) => c
102+
.clone()
103+
.shifted_in_from(TypeFolder::interner(self), outer_binder),
109104
_ => panic!("mismatched kinds in substitution"),
110105
}
111106
} else {
112-
Ok(bound_var
107+
bound_var
113108
.shifted_out()
114109
.unwrap()
115110
.shifted_in_from(outer_binder)
116-
.to_const(self.interner(), ty))
111+
.to_const(TypeFolder::interner(self), ty)
117112
}
118113
}
119114

‎chalk-ir/src/lib.rs

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,11 @@ extern crate self as chalk_ir;
88

99
use crate::cast::{Cast, CastTo, Caster};
1010
use crate::fold::shift::Shift;
11-
use crate::fold::{FallibleTypeFolder, Subst, TypeFoldable, TypeSuperFoldable};
11+
use crate::fold::{FallibleTypeFolder, Subst, TypeFoldable, TypeFolder, TypeSuperFoldable};
1212
use crate::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor, VisitExt};
13-
use chalk_derive::{HasInterner, TypeFoldable, TypeSuperVisitable, TypeVisitable, Zip};
13+
use chalk_derive::{
14+
FallibleTypeFolder, HasInterner, TypeFoldable, TypeSuperVisitable, TypeVisitable, Zip,
15+
};
1416
use std::marker::PhantomData;
1517
use std::ops::ControlFlow;
1618

@@ -2725,6 +2727,7 @@ impl<I: Interner> Substitution<I> {
27252727
}
27262728
}
27272729

2730+
#[derive(FallibleTypeFolder)]
27282731
struct SubstFolder<'i, I: Interner, A: AsParameters<I>> {
27292732
interner: I,
27302733
subst: &'i A,
@@ -2792,7 +2795,7 @@ impl<I: Interner, A: AsParameters<I>> Substitute<I> for A {
27922795
{
27932796
value
27942797
.try_fold_with(
2795-
&mut &SubstFolder {
2798+
&mut SubstFolder {
27962799
interner,
27972800
subst: self,
27982801
},
@@ -2825,45 +2828,42 @@ impl<'a, I: Interner> ToGenericArg<I> for (usize, &'a VariableKind<I>) {
28252828
}
28262829
}
28272830

2828-
impl<'i, I: Interner, A: AsParameters<I>> FallibleTypeFolder<I> for &SubstFolder<'i, I, A> {
2829-
type Error = NoSolution;
2830-
2831-
fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<I, Error = Self::Error> {
2831+
impl<'i, I: Interner, A: AsParameters<I>> TypeFolder<I> for SubstFolder<'i, I, A> {
2832+
fn as_dyn(&mut self) -> &mut dyn TypeFolder<I> {
28322833
self
28332834
}
28342835

2835-
fn try_fold_free_var_ty(
2836-
&mut self,
2837-
bound_var: BoundVar,
2838-
outer_binder: DebruijnIndex,
2839-
) -> Fallible<Ty<I>> {
2836+
fn fold_free_var_ty(&mut self, bound_var: BoundVar, outer_binder: DebruijnIndex) -> Ty<I> {
28402837
assert_eq!(bound_var.debruijn, DebruijnIndex::INNERMOST);
28412838
let ty = self.at(bound_var.index);
2842-
let ty = ty.assert_ty_ref(self.interner());
2843-
Ok(ty.clone().shifted_in_from(self.interner(), outer_binder))
2839+
let ty = ty.assert_ty_ref(TypeFolder::interner(self));
2840+
ty.clone()
2841+
.shifted_in_from(TypeFolder::interner(self), outer_binder)
28442842
}
28452843

2846-
fn try_fold_free_var_lifetime(
2844+
fn fold_free_var_lifetime(
28472845
&mut self,
28482846
bound_var: BoundVar,
28492847
outer_binder: DebruijnIndex,
2850-
) -> Fallible<Lifetime<I>> {
2848+
) -> Lifetime<I> {
28512849
assert_eq!(bound_var.debruijn, DebruijnIndex::INNERMOST);
28522850
let l = self.at(bound_var.index);
2853-
let l = l.assert_lifetime_ref(self.interner());
2854-
Ok(l.clone().shifted_in_from(self.interner(), outer_binder))
2851+
let l = l.assert_lifetime_ref(TypeFolder::interner(self));
2852+
l.clone()
2853+
.shifted_in_from(TypeFolder::interner(self), outer_binder)
28552854
}
28562855

2857-
fn try_fold_free_var_const(
2856+
fn fold_free_var_const(
28582857
&mut self,
28592858
_ty: Ty<I>,
28602859
bound_var: BoundVar,
28612860
outer_binder: DebruijnIndex,
2862-
) -> Fallible<Const<I>> {
2861+
) -> Const<I> {
28632862
assert_eq!(bound_var.debruijn, DebruijnIndex::INNERMOST);
28642863
let c = self.at(bound_var.index);
2865-
let c = c.assert_const_ref(self.interner());
2866-
Ok(c.clone().shifted_in_from(self.interner(), outer_binder))
2864+
let c = c.assert_const_ref(TypeFolder::interner(self));
2865+
c.clone()
2866+
.shifted_in_from(TypeFolder::interner(self), outer_binder)
28672867
}
28682868

28692869
fn interner(&self) -> I {

0 commit comments

Comments
 (0)