Skip to content

Commit 18487c3

Browse files
basil-cowbasil-cow
committed
add const types
1 parent 5d463e9 commit 18487c3

26 files changed

+428
-314
lines changed

‎chalk-integration/src/lowering.rs

+40-27
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ type TraitKinds = BTreeMap<chalk_ir::TraitId<ChalkIr>, TypeKind>;
2626
type AssociatedTyLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
2727
type AssociatedTyValueIds =
2828
BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
29-
type ParameterMap = BTreeMap<Ident, chalk_ir::ParameterKind<BoundVar>>;
29+
type ParameterMap = BTreeMap<Ident, chalk_ir::ParameterKind<ChalkIr, BoundVar>>;
3030

3131
pub type LowerResult<T> = Result<T, RustIrError>;
3232

@@ -65,7 +65,7 @@ impl<'k> Env<'k> {
6565
#[derive(Debug, PartialEq, Eq)]
6666
struct AssociatedTyLookup {
6767
id: chalk_ir::AssocTypeId<ChalkIr>,
68-
addl_parameter_kinds: Vec<chalk_ir::ParameterKind<()>>,
68+
addl_parameter_kinds: Vec<chalk_ir::ParameterKind<ChalkIr, ()>>,
6969
}
7070

7171
enum ApplyTypeLookup {
@@ -80,16 +80,16 @@ impl<'k> Env<'k> {
8080
let interner = self.interner();
8181

8282
if let Some(p) = self.parameter_map.get(&name.str) {
83-
return match *p {
84-
chalk_ir::ParameterKind::Ty(b) => Ok(chalk_ir::TyData::BoundVar(b)
83+
return match p {
84+
chalk_ir::ParameterKind::Ty(b) => Ok(chalk_ir::TyData::BoundVar(*b)
8585
.intern(interner)
8686
.cast(interner)),
87-
chalk_ir::ParameterKind::Lifetime(b) => Ok(chalk_ir::LifetimeData::BoundVar(b)
88-
.intern(interner)
89-
.cast(interner)),
90-
chalk_ir::ParameterKind::Const(b) => Ok(chalk_ir::ConstData::BoundVar(b)
87+
chalk_ir::ParameterKind::Lifetime(b) => Ok(chalk_ir::LifetimeData::BoundVar(*b)
9188
.intern(interner)
9289
.cast(interner)),
90+
chalk_ir::ParameterKind::Const { ty, value: b } => {
91+
Ok(b.to_const(interner, ty.clone()).cast(interner))
92+
}
9393
};
9494
}
9595

@@ -173,7 +173,7 @@ impl<'k> Env<'k> {
173173
/// will be assigned in order as they are iterated.
174174
fn introduce<I>(&self, binders: I) -> LowerResult<Self>
175175
where
176-
I: IntoIterator<Item = chalk_ir::ParameterKind<Ident>>,
176+
I: IntoIterator<Item = chalk_ir::ParameterKind<ChalkIr, Ident>>,
177177
I::IntoIter: ExactSizeIterator,
178178
{
179179
// As binders to introduce we recieve `ParameterKind<Ident>`,
@@ -192,7 +192,7 @@ impl<'k> Env<'k> {
192192
let parameter_map: ParameterMap = self
193193
.parameter_map
194194
.iter()
195-
.map(|(&k, &v)| (k, v.map(|b| b.shifted_in())))
195+
.map(|(k, v)| (*k, v.map_ref(|b| b.shifted_in())))
196196
.chain(binders)
197197
.collect();
198198
if parameter_map.len() != self.parameter_map.len() + len {
@@ -206,7 +206,7 @@ impl<'k> Env<'k> {
206206

207207
fn in_binders<I, T, OP>(&self, binders: I, op: OP) -> LowerResult<chalk_ir::Binders<T>>
208208
where
209-
I: IntoIterator<Item = chalk_ir::ParameterKind<Ident>>,
209+
I: IntoIterator<Item = chalk_ir::ParameterKind<ChalkIr, Ident>>,
210210
I::IntoIter: ExactSizeIterator,
211211
T: HasInterner<Interner = ChalkIr>,
212212
OP: FnOnce(&Self) -> LowerResult<T>,
@@ -499,9 +499,9 @@ trait LowerTypeKind {
499499
}
500500

501501
trait LowerParameterMap {
502-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>>;
502+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>>;
503503
fn declared_parameters(&self) -> &[ParameterKind];
504-
fn all_parameters(&self) -> Vec<chalk_ir::ParameterKind<Ident>> {
504+
fn all_parameters(&self) -> Vec<chalk_ir::ParameterKind<ChalkIr, Ident>> {
505505
self.synthetic_parameters()
506506
.into_iter()
507507
.chain(self.declared_parameters().iter().map(|id| id.lower()))
@@ -550,7 +550,7 @@ trait LowerParameterMap {
550550
}
551551

552552
impl LowerParameterMap for StructDefn {
553-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
553+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
554554
None
555555
}
556556

@@ -560,7 +560,7 @@ impl LowerParameterMap for StructDefn {
560560
}
561561

562562
impl LowerParameterMap for Impl {
563-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
563+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
564564
None
565565
}
566566

@@ -570,7 +570,7 @@ impl LowerParameterMap for Impl {
570570
}
571571

572572
impl LowerParameterMap for AssocTyDefn {
573-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
573+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
574574
None
575575
}
576576

@@ -580,7 +580,7 @@ impl LowerParameterMap for AssocTyDefn {
580580
}
581581

582582
impl LowerParameterMap for AssocTyValue {
583-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
583+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
584584
None
585585
}
586586

@@ -590,7 +590,7 @@ impl LowerParameterMap for AssocTyValue {
590590
}
591591

592592
impl LowerParameterMap for TraitDefn {
593-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
593+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
594594
Some(chalk_ir::ParameterKind::Ty(intern(SELF)))
595595
}
596596

@@ -600,7 +600,7 @@ impl LowerParameterMap for TraitDefn {
600600
}
601601

602602
impl LowerParameterMap for Clause {
603-
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<Ident>> {
603+
fn synthetic_parameters(&self) -> Option<chalk_ir::ParameterKind<ChalkIr, Ident>> {
604604
None
605605
}
606606

@@ -609,16 +609,28 @@ impl LowerParameterMap for Clause {
609609
}
610610
}
611611

612+
fn get_type_of_u32() -> chalk_ir::Ty<ChalkIr> {
613+
chalk_ir::ApplicationTy {
614+
name: chalk_ir::TypeName::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)),
615+
substitution: Substitution::empty(&ChalkIr),
616+
}
617+
.cast(&ChalkIr)
618+
.intern(&ChalkIr)
619+
}
620+
612621
trait LowerParameterKind {
613-
fn lower(&self) -> chalk_ir::ParameterKind<Ident>;
622+
fn lower(&self) -> chalk_ir::ParameterKind<ChalkIr, Ident>;
614623
}
615624

616625
impl LowerParameterKind for ParameterKind {
617-
fn lower(&self) -> chalk_ir::ParameterKind<Ident> {
626+
fn lower(&self) -> chalk_ir::ParameterKind<ChalkIr, Ident> {
618627
match *self {
619628
ParameterKind::Ty(ref n) => chalk_ir::ParameterKind::Ty(n.str),
620629
ParameterKind::Lifetime(ref n) => chalk_ir::ParameterKind::Lifetime(n.str),
621-
ParameterKind::Const(ref n) => chalk_ir::ParameterKind::Const(n.str),
630+
ParameterKind::Const(ref n) => chalk_ir::ParameterKind::Const {
631+
ty: get_type_of_u32(),
632+
value: n.str,
633+
},
622634
}
623635
}
624636
}
@@ -1233,9 +1245,10 @@ impl LowerParameter for Parameter {
12331245
Parameter::Ty(ref t) => Ok(t.lower(env)?.cast(interner)),
12341246
Parameter::Lifetime(ref l) => Ok(l.lower(env)?.cast(interner)),
12351247
Parameter::Id(name) => env.lookup_parameter(name),
1236-
Parameter::ConstValue(value) => Ok(chalk_ir::ConstData::Concrete(
1237-
chalk_ir::ConcreteConst { interned: value },
1238-
)
1248+
Parameter::ConstValue(value) => Ok(chalk_ir::ConstData {
1249+
ty: get_type_of_u32(),
1250+
value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: value }),
1251+
}
12391252
.intern(interner)
12401253
.cast(interner)),
12411254
}
@@ -1560,12 +1573,12 @@ impl Kinded for ParameterKind {
15601573
}
15611574
}
15621575

1563-
impl<T, L, C> Kinded for chalk_ir::ParameterKind<T, L, C> {
1576+
impl<I: chalk_ir::interner::Interner, T, L, C> Kinded for chalk_ir::ParameterKind<I, T, L, C> {
15641577
fn kind(&self) -> Kind {
15651578
match *self {
15661579
chalk_ir::ParameterKind::Ty(_) => Kind::Ty,
15671580
chalk_ir::ParameterKind::Lifetime(_) => Kind::Lifetime,
1568-
chalk_ir::ParameterKind::Const(_) => Kind::Const,
1581+
chalk_ir::ParameterKind::Const { .. } => Kind::Const,
15691582
}
15701583
}
15711584
}

‎chalk-ir/src/cast.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -177,7 +177,8 @@ impl<I: Interner> CastTo<Parameter<I>> for Lifetime<I> {
177177

178178
impl<I: Interner> CastTo<Parameter<I>> for Const<I> {
179179
fn cast_to(self, interner: &I) -> Parameter<I> {
180-
Parameter::new(interner, ParameterKind::Const(self))
180+
let ty = self.data(interner).ty.clone();
181+
Parameter::new(interner, ParameterKind::Const { ty, value: self })
181182
}
182183
}
183184

‎chalk-ir/src/debug.rs

+13-10
Original file line numberDiff line numberDiff line change
@@ -265,7 +265,7 @@ impl<'a, I: Interner> Debug for ParameterKindsInnerDebug<'a, I> {
265265
match *binder {
266266
ParameterKind::Ty(()) => write!(fmt, "type")?,
267267
ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
268-
ParameterKind::Const(()) => write!(fmt, "const")?,
268+
ParameterKind::Const { ref ty, value: () } => write!(fmt, "const: {:?}", ty)?,
269269
}
270270
}
271271
write!(fmt, ">")
@@ -274,11 +274,11 @@ impl<'a, I: Interner> Debug for ParameterKindsInnerDebug<'a, I> {
274274

275275
impl<I: Interner> Debug for ConstData<I> {
276276
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
277-
match self {
278-
ConstData::BoundVar(db) => write!(fmt, "{:?}", db),
279-
ConstData::InferenceVar(var) => write!(fmt, "{:?}", var),
280-
ConstData::Placeholder(index) => write!(fmt, "{:?}", index),
281-
ConstData::Concrete(evaluated) => write!(fmt, "{:?}", evaluated),
277+
match &self.value {
278+
ConstValue::BoundVar(db) => write!(fmt, "{:?}", db),
279+
ConstValue::InferenceVar(var) => write!(fmt, "{:?}", var),
280+
ConstValue::Placeholder(index) => write!(fmt, "{:?}", index),
281+
ConstValue::Concrete(evaluated) => write!(fmt, "{:?}", evaluated),
282282
}
283283
}
284284
}
@@ -338,7 +338,7 @@ impl<'a, I: Interner> Debug for ParameterDataInnerDebug<'a, I> {
338338
match self.0 {
339339
ParameterKind::Ty(n) => write!(fmt, "{:?}", n),
340340
ParameterKind::Lifetime(n) => write!(fmt, "{:?}", n),
341-
ParameterKind::Const(n) => write!(fmt, "{:?}", n),
341+
ParameterKind::Const { value: n, .. } => write!(fmt, "{:?}", n),
342342
}
343343
}
344344
}
@@ -728,7 +728,7 @@ impl<'a, T: HasInterner + Display> Display for CanonicalDisplay<'a, T> {
728728
if i > 0 {
729729
write!(f, ",")?;
730730
}
731-
write!(f, "?{}", pk.into_inner())?;
731+
write!(f, "?{}", pk.as_ref().into_inner())?;
732732
}
733733

734734
write!(f, "> {{ {} }}", value)?;
@@ -738,12 +738,15 @@ impl<'a, T: HasInterner + Display> Display for CanonicalDisplay<'a, T> {
738738
}
739739
}
740740

741-
impl<T: Debug, L: Debug, C: Debug> Debug for ParameterKind<T, L, C> {
741+
impl<I: Interner, T: Debug, L: Debug, C: Debug> Debug for ParameterKind<I, T, L, C> {
742742
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
743743
match *self {
744744
ParameterKind::Ty(ref n) => write!(fmt, "Ty({:?})", n),
745745
ParameterKind::Lifetime(ref n) => write!(fmt, "Lifetime({:?})", n),
746-
ParameterKind::Const(ref n) => write!(fmt, "Const({:?})", n),
746+
ParameterKind::Const {
747+
ref ty,
748+
value: ref n,
749+
} => write!(fmt, "Const({:?}: {:?})", n, ty),
747750
}
748751
}
749752
}

‎chalk-ir/src/fold.rs

+32-13
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,7 @@ where
173173

174174
fn fold_free_var_const(
175175
&mut self,
176+
ty: &Ty<I>,
176177
bound_var: BoundVar,
177178
outer_binder: DebruijnIndex,
178179
) -> Fallible<Const<TI>> {
@@ -183,7 +184,11 @@ where
183184
)
184185
} else {
185186
let bound_var = bound_var.shifted_in_from(outer_binder);
186-
Ok(ConstData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
187+
Ok(ConstData {
188+
ty: ty.fold_with(self.as_dyn(), outer_binder)?,
189+
value: ConstValue::<TI>::BoundVar(bound_var),
190+
}
191+
.intern(self.target_interner()))
187192
}
188193
}
189194

@@ -230,13 +235,17 @@ where
230235
#[allow(unused_variables)]
231236
fn fold_free_placeholder_const(
232237
&mut self,
238+
ty: &Ty<I>,
233239
universe: PlaceholderIndex,
234240
outer_binder: DebruijnIndex,
235241
) -> Fallible<Const<TI>> {
236242
if self.forbid_free_placeholders() {
237243
panic!("unexpected placeholder const `{:?}`", universe)
238244
} else {
239-
Ok(universe.to_const(self.target_interner()))
245+
Ok(universe.to_const(
246+
self.target_interner(),
247+
ty.fold_with(self.as_dyn(), outer_binder)?,
248+
))
240249
}
241250
}
242251

@@ -284,13 +293,17 @@ where
284293
#[allow(unused_variables)]
285294
fn fold_inference_const(
286295
&mut self,
296+
ty: &Ty<I>,
287297
var: InferenceVar,
288298
outer_binder: DebruijnIndex,
289299
) -> Fallible<Const<TI>> {
290300
if self.forbid_inference_vars() {
291301
panic!("unexpected inference const `{:?}`", var)
292302
} else {
293-
Ok(var.to_const(self.target_interner()))
303+
Ok(var.to_const(
304+
self.target_interner(),
305+
ty.fold_with(self.as_dyn(), outer_binder)?,
306+
))
294307
}
295308
}
296309

@@ -507,21 +520,27 @@ where
507520
TI: 'i,
508521
{
509522
let interner = folder.interner();
510-
match self.data(interner) {
511-
ConstData::BoundVar(bound_var) => {
523+
let target_interner = folder.target_interner();
524+
let ConstData { ref ty, ref value } = self.data(interner);
525+
let mut fold_ty = || ty.fold_with(folder, outer_binder);
526+
match value {
527+
ConstValue::BoundVar(bound_var) => {
512528
if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) {
513-
folder.fold_free_var_const(bound_var1, outer_binder)
529+
folder.fold_free_var_const(ty, bound_var1, outer_binder)
514530
} else {
515-
Ok(ConstData::<TI>::BoundVar(*bound_var).intern(folder.target_interner()))
531+
Ok(bound_var.to_const(target_interner, fold_ty()?))
516532
}
517533
}
518-
ConstData::InferenceVar(var) => folder.fold_inference_const(*var, outer_binder),
519-
ConstData::Placeholder(universe) => {
520-
folder.fold_free_placeholder_const(*universe, outer_binder)
534+
ConstValue::InferenceVar(var) => folder.fold_inference_const(ty, *var, outer_binder),
535+
ConstValue::Placeholder(universe) => {
536+
folder.fold_free_placeholder_const(ty, *universe, outer_binder)
537+
}
538+
ConstValue::Concrete(ev) => Ok(ConstData {
539+
ty: fold_ty()?,
540+
value: ConstValue::Concrete(ConcreteConst {
541+
interned: folder.target_interner().transfer_const(&ev.interned),
542+
}),
521543
}
522-
ConstData::Concrete(ev) => Ok(ConstData::Concrete(ConcreteConst {
523-
interned: folder.target_interner().transfer_const(&ev.interned),
524-
})
525544
.intern(folder.target_interner())),
526545
}
527546
}

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

+6-3
Original file line numberDiff line numberDiff line change
@@ -331,13 +331,13 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
331331
}
332332
}
333333

334-
impl<I: Interner, TI: TargetInterner<I>, T, L, C> Fold<I, TI> for ParameterKind<T, L, C>
334+
impl<I: Interner, TI: TargetInterner<I>, T, L, C> Fold<I, TI> for ParameterKind<I, T, L, C>
335335
where
336336
T: Fold<I, TI>,
337337
L: Fold<I, TI>,
338338
C: Fold<I, TI>,
339339
{
340-
type Result = ParameterKind<T::Result, L::Result, C::Result>;
340+
type Result = ParameterKind<TI, T::Result, L::Result, C::Result>;
341341

342342
fn fold_with<'i>(
343343
&self,
@@ -353,7 +353,10 @@ where
353353
ParameterKind::Lifetime(a) => {
354354
Ok(ParameterKind::Lifetime(a.fold_with(folder, outer_binder)?))
355355
}
356-
ParameterKind::Const(a) => Ok(ParameterKind::Const(a.fold_with(folder, outer_binder)?)),
356+
ParameterKind::Const { ty, value } => Ok(ParameterKind::Const {
357+
ty: ty.fold_with(folder, outer_binder)?,
358+
value: value.fold_with(folder, outer_binder)?,
359+
}),
357360
}
358361
}
359362
}

0 commit comments

Comments
 (0)