Skip to content

Commit 86d7bca

Browse files
basil-cowbasil-cow
committed
const implementation mvp
1 parent c0daf93 commit 86d7bca

File tree

28 files changed

+968
-203
lines changed

28 files changed

+968
-203
lines changed

‎chalk-integration/src/error.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,7 @@ impl std::error::Error for ChalkError {}
5656
pub enum RustIrError {
5757
InvalidTypeName(Identifier),
5858
InvalidLifetimeName(Identifier),
59+
InvalidConstName(Identifier),
5960
NotTrait(Identifier),
6061
NotStruct(Identifier),
6162
DuplicateOrShadowedParameters,
@@ -98,6 +99,7 @@ impl std::fmt::Display for RustIrError {
9899
match self {
99100
RustIrError::InvalidTypeName(name) => write!(f, "invalid type name `{}`", name),
100101
RustIrError::InvalidLifetimeName(name) => write!(f, "invalid lifetime name `{}`", name),
102+
RustIrError::InvalidConstName(name) => write!(f, "invalid const name `{}`", name),
101103
RustIrError::NotTrait(name) => write!(
102104
f,
103105
"expected a trait, found `{}`, which is not a trait",

‎chalk-integration/src/lowering.rs

Lines changed: 45 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -85,6 +85,10 @@ enum LifetimeLookup {
8585
GenericArg(BoundVar),
8686
}
8787

88+
enum ConstLookup {
89+
Parameter(BoundVar),
90+
}
91+
8892
const SELF: &str = "Self";
8993
const FIXME_SELF: &str = "__FIXME_SELF__";
9094

@@ -153,6 +157,17 @@ impl<'k> Env<'k> {
153157
&self.fn_def_kinds[&id]
154158
}
155159

160+
fn lookup_const(&self, name: Identifier) -> LowerResult<ConstLookup> {
161+
if let Some(k) = self
162+
.parameter_map
163+
.get(&chalk_ir::ParameterKind::Const(name.str))
164+
{
165+
return Ok(ConstLookup::Parameter(*k));
166+
}
167+
168+
Err(RustIrError::InvalidConstName(name))
169+
}
170+
156171
fn trait_kind(&self, id: chalk_ir::TraitId<ChalkIr>) -> &TypeKind {
157172
&self.trait_kinds[&id]
158173
}
@@ -867,6 +882,11 @@ impl LowerLeafGoal for LeafGoal {
867882
b: b.lower(env)?.cast(interner),
868883
}
869884
.cast::<chalk_ir::Goal<ChalkIr>>(interner),
885+
LeafGoal::UnifyConsts { ref a, ref b } => chalk_ir::EqGoal {
886+
a: a.lower(env)?.cast(interner),
887+
b: b.lower(env)?.cast(interner),
888+
}
889+
.cast::<chalk_ir::Goal<ChalkIr>>(interner),
870890
})
871891
}
872892
}
@@ -1409,6 +1429,28 @@ impl LowerGenericArg for GenericArg {
14091429
match *self {
14101430
GenericArg::Ty(ref t) => Ok(t.lower(env)?.cast(interner)),
14111431
GenericArg::Lifetime(ref l) => Ok(l.lower(env)?.cast(interner)),
1432+
GenericArg::Const(ref c) => Ok(c.lower(env)?.cast(interner)),
1433+
}
1434+
}
1435+
}
1436+
1437+
trait LowerConst {
1438+
fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>>;
1439+
}
1440+
1441+
impl LowerConst for Const {
1442+
fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>> {
1443+
let interner = env.interner();
1444+
match *self {
1445+
Const::Id { name } => match env.lookup_const(name)? {
1446+
ConstLookup::Parameter(d) => Ok(chalk_ir::ConstData::BoundVar(d).intern(interner)),
1447+
},
1448+
Const::Value { value } => {
1449+
Ok(
1450+
chalk_ir::ConstData::Concrete(chalk_ir::ConcreteConst { interned: value })
1451+
.intern(interner),
1452+
)
1453+
}
14121454
}
14131455
}
14141456
}
@@ -1722,6 +1764,7 @@ impl Kinded for VariableKind {
17221764
match *self {
17231765
VariableKind::Ty(_) => Kind::Ty,
17241766
VariableKind::Lifetime(_) => Kind::Lifetime,
1767+
VariableKind::Const(_) => Kind::Const,
17251768
}
17261769
}
17271770
}
@@ -1731,6 +1774,7 @@ impl Kinded for GenericArg {
17311774
match *self {
17321775
GenericArg::Ty(_) => Kind::Ty,
17331776
GenericArg::Lifetime(_) => Kind::Lifetime,
1777+
GenericArg::Const(_) => Kind::Const,
17341778
}
17351779
}
17361780
}
@@ -1740,7 +1784,7 @@ impl Kinded for chalk_ir::VariableKind<ChalkIr> {
17401784
match self {
17411785
chalk_ir::VariableKind::Ty => Kind::Ty,
17421786
chalk_ir::VariableKind::Lifetime => Kind::Lifetime,
1743-
chalk_ir::VariableKind::Phantom(..) => unreachable!(),
1787+
chalk_ir::VariableKind::Const(_) => Kind::Const,
17441788
}
17451789
}
17461790
}

‎chalk-ir/src/cast.rs

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,7 @@ macro_rules! reflexive_impl {
7676

7777
reflexive_impl!(for(I: Interner) TyData<I>);
7878
reflexive_impl!(for(I: Interner) LifetimeData<I>);
79+
reflexive_impl!(for(I: Interner) ConstData<I>);
7980
reflexive_impl!(for(I: Interner) TraitRef<I>);
8081
reflexive_impl!(for(I: Interner) DomainGoal<I>);
8182
reflexive_impl!(for(I: Interner) Goal<I>);
@@ -174,6 +175,12 @@ impl<I: Interner> CastTo<GenericArg<I>> for Lifetime<I> {
174175
}
175176
}
176177

178+
impl<I: Interner> CastTo<Parameter<I>> for Const<I> {
179+
fn cast_to(self, interner: &I) -> Parameter<I> {
180+
Parameter::new(interner, ParameterKind::Const(self))
181+
}
182+
}
183+
177184
impl<I: Interner> CastTo<GenericArg<I>> for GenericArg<I> {
178185
fn cast_to(self, _interner: &I) -> GenericArg<I> {
179186
self

‎chalk-ir/src/could_match.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,10 @@ where
4848
Ok(())
4949
}
5050

51+
fn zip_consts(&mut self, _: &Const<I>, _: &Const<I>) -> Fallible<()> {
52+
Ok(())
53+
}
54+
5155
fn zip_binders<T>(&mut self, a: &Binders<T>, b: &Binders<T>) -> Fallible<()>
5256
where
5357
T: HasInterner + Zip<I>,

‎chalk-ir/src/debug.rs

Lines changed: 28 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,18 @@ impl<I: Interner> Debug for Lifetime<I> {
3939
}
4040
}
4141

42+
impl<I: Interner> Debug for Const<I> {
43+
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
44+
I::debug_const(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
45+
}
46+
}
47+
48+
impl<I: Interner> Debug for ConcreteConst<I> {
49+
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
50+
write!(fmt, "{:?}", self.interned)
51+
}
52+
}
53+
4254
impl<I: Interner> Debug for GenericArg<I> {
4355
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
4456
I::debug_generic_arg(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
@@ -264,13 +276,24 @@ impl<'a, I: Interner> Debug for VariableKindsInnerDebug<'a, I> {
264276
match *binder {
265277
VariableKind::Ty => write!(fmt, "type")?,
266278
VariableKind::Lifetime => write!(fmt, "lifetime")?,
267-
VariableKind::Phantom(..) => unreachable!(),
279+
VariableKind::Const(()) => write!(fmt, "const")?,
268280
}
269281
}
270282
write!(fmt, ">")
271283
}
272284
}
273285

286+
impl<I: Interner> Debug for ConstData<I> {
287+
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
288+
match self {
289+
ConstData::BoundVar(db) => write!(fmt, "{:?}", db),
290+
ConstData::InferenceVar(var) => write!(fmt, "{:?}", var),
291+
ConstData::Placeholder(index) => write!(fmt, "{:?}", index),
292+
ConstData::Concrete(evaluated) => write!(fmt, "{:?}", evaluated),
293+
}
294+
}
295+
}
296+
274297
impl<I: Interner> Debug for GoalData<I> {
275298
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
276299
match self {
@@ -326,6 +349,7 @@ impl<'a, I: Interner> Debug for GenericArgDataInnerDebug<'a, I> {
326349
match self.0 {
327350
GenericArgData::Ty(n) => write!(fmt, "{:?}", n),
328351
GenericArgData::Lifetime(n) => write!(fmt, "{:?}", n),
352+
GenericArgData::Const(n) => write!(fmt, "{:?}", n),
329353
}
330354
}
331355
}
@@ -731,6 +755,7 @@ impl<I: Interner> Debug for GenericArgData<I> {
731755
match self {
732756
GenericArgData::Ty(t) => write!(fmt, "Ty({:?})", t),
733757
GenericArgData::Lifetime(l) => write!(fmt, "Lifetime({:?})", l),
758+
GenericArgData::Const(c) => write!(fmt, "Const({:?})", c),
734759
}
735760
}
736761
}
@@ -740,7 +765,7 @@ impl<I: Interner> Debug for VariableKind<I> {
740765
match *self {
741766
VariableKind::Ty => write!(fmt, "type"),
742767
VariableKind::Lifetime => write!(fmt, "lifetime"),
743-
VariableKind::Phantom(..) => unreachable!(),
768+
VariableKind::Const(ty) => write!(fmt, "const: {:?}", ty),
744769
}
745770
}
746771
}
@@ -751,7 +776,7 @@ impl<I: Interner, T: Debug> Debug for WithKind<I, T> {
751776
match &self.kind {
752777
VariableKind::Ty => write!(fmt, "{:?} with kind type", value),
753778
VariableKind::Lifetime => write!(fmt, "{:?} with kind lifetime", value),
754-
VariableKind::Phantom(..) => unreachable!(),
779+
VariableKind::Const(ty) => write!(fmt, "{:?} with kind {:?}", ty),
755780
}
756781
}
757782
}

‎chalk-ir/src/fold.rs

Lines changed: 111 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ where
8787
/// Top-level callback: invoked for each `Lifetime<I>` that is
8888
/// encountered when folding. By default, invokes
8989
/// `super_fold_with`, which will in turn invoke the more
90-
/// specialized folding methods below, like `fold_free_lifetime_ty`.
90+
/// specialized folding methods below, like `fold_free_var_lifetime`.
9191
fn fold_lifetime(
9292
&mut self,
9393
lifetime: &Lifetime<I>,
@@ -96,6 +96,18 @@ where
9696
lifetime.super_fold_with(self.as_dyn(), outer_binder)
9797
}
9898

99+
/// Top-level callback: invoked for each `Const<I>` that is
100+
/// encountered when folding. By default, invokes
101+
/// `super_fold_with`, which will in turn invoke the more
102+
/// specialized folding methods below, like `fold_free_var_const`.
103+
fn fold_const(
104+
&mut self,
105+
constant: &Const<I>,
106+
outer_binder: DebruijnIndex,
107+
) -> Fallible<Const<TI>> {
108+
constant.super_fold_with(self.as_dyn(), outer_binder)
109+
}
110+
99111
/// Invoked for every program clause. By default, recursively folds the goals contents.
100112
fn fold_program_clause(
101113
&mut self,
@@ -159,8 +171,24 @@ where
159171
}
160172
}
161173

162-
/// If overriden to return true, we will panic when a free
163-
/// placeholder type/lifetime is encountered.
174+
fn fold_free_var_const(
175+
&mut self,
176+
bound_var: BoundVar,
177+
outer_binder: DebruijnIndex,
178+
) -> Fallible<Const<TI>> {
179+
if self.forbid_free_vars() {
180+
panic!(
181+
"unexpected free variable with depth `{:?}` with outer binder {:?}",
182+
bound_var, outer_binder
183+
)
184+
} else {
185+
let bound_var = bound_var.shifted_in_from(outer_binder);
186+
Ok(ConstData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
187+
}
188+
}
189+
190+
/// If overridden to return true, we will panic when a free
191+
/// placeholder type/lifetime/const is encountered.
164192
fn forbid_free_placeholders(&self) -> bool {
165193
false
166194
}
@@ -199,6 +227,19 @@ where
199227
}
200228
}
201229

230+
#[allow(unused_variables)]
231+
fn fold_free_placeholder_const(
232+
&mut self,
233+
universe: PlaceholderIndex,
234+
outer_binder: DebruijnIndex,
235+
) -> Fallible<Const<TI>> {
236+
if self.forbid_free_placeholders() {
237+
panic!("unexpected placeholder const `{:?}`", universe)
238+
} else {
239+
Ok(universe.to_const(self.target_interner()))
240+
}
241+
}
242+
202243
/// If overridden to return true, inference variables will trigger
203244
/// panics when folded. Used when inference variables are
204245
/// unexpected.
@@ -240,6 +281,19 @@ where
240281
}
241282
}
242283

284+
#[allow(unused_variables)]
285+
fn fold_inference_const(
286+
&mut self,
287+
var: InferenceVar,
288+
outer_binder: DebruijnIndex,
289+
) -> Fallible<Const<TI>> {
290+
if self.forbid_inference_vars() {
291+
panic!("unexpected inference const `{:?}`", var)
292+
} else {
293+
Ok(var.to_const(self.target_interner()))
294+
}
295+
}
296+
243297
fn interner(&self) -> &'i I;
244298

245299
fn target_interner(&self) -> &'i TI;
@@ -419,6 +473,60 @@ where
419473
}
420474
}
421475

476+
/// "Folding" a const invokes the `fold_const` method on the folder; this
477+
/// usually (in turn) invokes `super_fold_const` to fold the individual
478+
/// parts.
479+
impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Const<I> {
480+
type Result = Const<TI>;
481+
482+
fn fold_with<'i>(
483+
&self,
484+
folder: &mut dyn Folder<'i, I, TI>,
485+
outer_binder: DebruijnIndex,
486+
) -> Fallible<Self::Result>
487+
where
488+
I: 'i,
489+
TI: 'i,
490+
{
491+
folder.fold_const(self, outer_binder)
492+
}
493+
}
494+
495+
impl<I, TI> SuperFold<I, TI> for Const<I>
496+
where
497+
I: Interner,
498+
TI: TargetInterner<I>,
499+
{
500+
fn super_fold_with<'i>(
501+
&self,
502+
folder: &mut dyn Folder<'i, I, TI>,
503+
outer_binder: DebruijnIndex,
504+
) -> Fallible<Const<TI>>
505+
where
506+
I: 'i,
507+
TI: 'i,
508+
{
509+
let interner = folder.interner();
510+
match self.data(interner) {
511+
ConstData::BoundVar(bound_var) => {
512+
if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) {
513+
folder.fold_free_var_const(bound_var1, outer_binder)
514+
} else {
515+
Ok(ConstData::<TI>::BoundVar(*bound_var).intern(folder.target_interner()))
516+
}
517+
}
518+
ConstData::InferenceVar(var) => folder.fold_inference_const(*var, outer_binder),
519+
ConstData::Placeholder(universe) => {
520+
folder.fold_free_placeholder_const(*universe, outer_binder)
521+
}
522+
ConstData::Concrete(ev) => Ok(ConstData::Concrete(ConcreteConst {
523+
interned: folder.target_interner().transfer_const(&ev.interned),
524+
})
525+
.intern(folder.target_interner())),
526+
}
527+
}
528+
}
529+
422530
/// Folding a goal invokes the `fold_goal` callback (which will, by
423531
/// default, invoke super-fold).
424532
impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goal<I> {

0 commit comments

Comments
 (0)