Skip to content

Commit

Permalink
Merge pull request #354 from yaahc/jane/intern-substitution-data
Browse files Browse the repository at this point in the history 
Add self param to Interner::substitution_data
  • Loading branch information
@nikomatsakis
nikomatsakis authored Mar 19, 2020
2 parents b7ed5e0 + 886553e commit 1ac0d00
Show file tree
Hide file tree
Showing 17 changed files with 288 additions and 153 deletions.
2 changes: 1 addition & 1 deletion chalk-integration/src/lowering.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -949,7 +949,7 @@ impl LowerAliasTy for AliasTy {
}
}

args.extend(trait_substitution.iter().cloned());
args.extend(trait_substitution.iter(interner).cloned());

Ok(chalk_ir::AliasTy {
associated_ty_id: lookup.id,
Expand Down
64 changes: 60 additions & 4 deletions chalk-integration/src/program.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,9 @@ use chalk_ir::debug::Angle;
use chalk_ir::interner::ChalkIr;
use chalk_ir::tls;
use chalk_ir::{
AliasTy, AssocTypeId, Goal, GoalData, Goals, ImplId, Lifetime, Parameter, ParameterKind,
ProgramClause, ProgramClauseImplication, StructId, TraitId, Ty, TyData, TypeName,
debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, Goal, GoalData, Goals, ImplId,
Lifetime, Parameter, ParameterKind, ProgramClause, ProgramClauseImplication, StructId,
Substitution, TraitId, Ty, TyData, TypeName,
};
use chalk_rust_ir::{
AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
Expand Down Expand Up @@ -215,6 +216,61 @@ impl tls::DebugContext for Program {
}
write!(fmt, "{:?}", conditions[conds - 1])
}

fn debug_application_ty(
&self,
application_ty: &ApplicationTy<ChalkIr>,
fmt: &mut fmt::Formatter<'_>,
) -> Result<(), fmt::Error> {
let interner = self.interner();
let ApplicationTy { name, substitution } = application_ty;
write!(fmt, "{:?}{:?}", name, substitution.with_angle(interner))
}

fn debug_substitution(
&self,
substitution: &Substitution<ChalkIr>,
fmt: &mut fmt::Formatter<'_>,
) -> Result<(), fmt::Error> {
let interner = self.interner();
let mut first = true;

write!(fmt, "[")?;

for (index, value) in substitution.iter(interner).enumerate() {
if first {
first = false;
} else {
write!(fmt, ", ")?;
}

write!(fmt, "?{} := {:?}", index, value)?;
}

write!(fmt, "]")?;

Ok(())
}

fn debug_separator_trait_ref(
&self,
separator_trait_ref: &SeparatorTraitRef<ChalkIr>,
fmt: &mut fmt::Formatter<'_>,
) -> Result<(), fmt::Error> {
let interner = self.interner();
let parameters = separator_trait_ref
.trait_ref
.substitution
.parameters(interner);
write!(
fmt,
"{:?}{}{:?}{:?}",
parameters[0],
separator_trait_ref.separator,
separator_trait_ref.trait_ref.trait_id,
Angle(&parameters[1..])
)
}
}

impl RustIrDatabase<ChalkIr> for Program {
Expand Down Expand Up @@ -263,11 +319,11 @@ impl RustIrDatabase<ChalkIr> for Program {
.filter(|(_, impl_datum)| {
let trait_ref = &impl_datum.binders.value.trait_ref;
trait_id == trait_ref.trait_id && {
assert_eq!(trait_ref.substitution.len(), parameters.len());
assert_eq!(trait_ref.substitution.len(interner), parameters.len());
<[_] as CouldMatch<[_]>>::could_match(
&parameters,
interner,
&trait_ref.substitution.parameters(),
&trait_ref.substitution.parameters(interner),
)
}
})
Expand Down
9 changes: 5 additions & 4 deletions chalk-ir/src/could_match.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,15 +22,16 @@ where

impl<'i, I: Interner> Zipper<'i, I> for MatchZipper<'i, I> {
fn zip_tys(&mut self, a: &Ty<I>, b: &Ty<I>) -> Fallible<()> {
let could_match = match (a.data(self.interner), b.data(self.interner)) {
let interner = self.interner;
let could_match = match (a.data(interner), b.data(interner)) {
(&TyData::Apply(ref a), &TyData::Apply(ref b)) => {
let names_could_match = a.name == b.name;

names_could_match
&& a.substitution
.iter()
.zip(&b.substitution)
.all(|(p_a, p_b)| p_a.could_match(self.interner, &p_b))
.iter(interner)
.zip(b.substitution.iter(interner))
.all(|(p_a, p_b)| p_a.could_match(interner, &p_b))
}

_ => true,
Expand Down
119 changes: 52 additions & 67 deletions chalk-ir/src/debug.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,37 +23,78 @@ impl<I: Interner> Debug for AssocTypeId<I> {

impl<I: Interner> Debug for Ty<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_ty(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_ty(self, fmt)
.unwrap_or_else(|| unimplemented!("cannot format Ty without setting Program in tls"))
}
}

impl<I: Interner> Debug for Lifetime<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_lifetime(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_lifetime(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format Lifetime without setting Program in tls")
})
}
}

impl<I: Interner> Debug for Parameter<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_parameter(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_parameter(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format Parameter without setting Program in tls")
})
}
}

impl<I: Interner> Debug for Goal<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_goal(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_goal(self, fmt)
.unwrap_or_else(|| unimplemented!("cannot format Goal without setting Program in tls"))
}
}

impl<I: Interner> Debug for Goals<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_goals(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_goals(self, fmt)
.unwrap_or_else(|| unimplemented!("cannot format Goals without setting Program in tls"))
}
}

impl<I: Interner> Debug for ProgramClauseImplication<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_program_clause_implication(self, fmt).unwrap_or_else(|| unimplemented!())
I::debug_program_clause_implication(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format ProgramClauseImplication without setting Program in tls")
})
}
}

impl<I: Interner> Debug for ApplicationTy<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_application_ty(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format ApplicationTy without setting Program in tls")
})
}
}

impl<I: Interner> Debug for SeparatorTraitRef<'_, I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_separator_trait_ref(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format Substitution without setting Program in tls")
})
}
}

impl<I: Interner> Debug for AliasTy<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_alias(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format AliasTy without setting Program in tls")
})
}
}

impl<I: Interner> Display for Substitution<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_substitution(self, fmt).unwrap_or_else(|| {
unimplemented!("cannot format Substitution without setting Program in tls")
})
}
}

Expand Down Expand Up @@ -135,13 +176,6 @@ impl Debug for PlaceholderIndex {
}
}

impl<I: Interner> Debug for ApplicationTy<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
let ApplicationTy { name, substitution } = self;
write!(fmt, "{:?}{:?}", name, substitution.with_angle())
}
}

impl<I: Interner> TraitRef<I> {
/// Returns a "Debuggable" type that prints like `P0 as Trait<P1..>`
pub fn with_as(&self) -> impl std::fmt::Debug + '_ {
Expand All @@ -166,36 +200,9 @@ impl<I: Interner> Debug for TraitRef<I> {
}
}

struct SeparatorTraitRef<'me, I: Interner> {
trait_ref: &'me TraitRef<I>,
separator: &'me str,
}

impl<I: Interner> Debug for SeparatorTraitRef<'_, I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
let parameters = self.trait_ref.substitution.parameters();
write!(
fmt,
"{:?}{}{:?}{:?}",
parameters[0],
self.separator,
self.trait_ref.trait_id,
Angle(&parameters[1..])
)
}
}

impl<I: Interner> Debug for AliasTy<I> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
I::debug_alias(self, fmt).unwrap_or_else(|| {
write!(
fmt,
"({:?}){:?}",
self.associated_ty_id,
self.substitution.with_angle()
)
})
}
pub struct SeparatorTraitRef<'me, I: Interner> {
pub trait_ref: &'me TraitRef<I>,
pub separator: &'me str,
}

pub struct Angle<'a, T>(pub &'a [T]);
Expand Down Expand Up @@ -374,8 +381,8 @@ impl<I: Interner> Display for ConstrainedSubst<I> {
impl<I: Interner> Substitution<I> {
/// Displays the substitution in the form `< P0, .. Pn >`, or (if
/// the substitution is empty) as an empty string.
pub fn with_angle(&self) -> Angle<'_, Parameter<I>> {
Angle(self.parameters())
pub fn with_angle(&self, interner: &I) -> Angle<'_, Parameter<I>> {
Angle(self.parameters(interner))
}
}

Expand All @@ -384,25 +391,3 @@ impl<I: Interner> Debug for Substitution<I> {
Display::fmt(self, fmt)
}
}

impl<I: Interner> Display for Substitution<I> {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
let mut first = true;

write!(f, "[")?;

for (index, value) in self.iter().enumerate() {
if first {
first = false;
} else {
write!(f, ", ")?;
}

write!(f, "?{} := {:?}", index, value)?;
}

write!(f, "]")?;

Ok(())
}
}
7 changes: 4 additions & 3 deletions chalk-ir/src/fold/boring_impls.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -141,9 +141,10 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Substitution<I> {
I: 'i,
TI: 'i,
{
let interner = folder.target_interner();
let folded = self.iter().map(|p| p.fold_with(folder, binders));
Ok(Substitution::from_fallible(interner, folded)?)
let interner = folder.interner();
let target_interner = folder.target_interner();
let folded = self.iter(interner).map(|p| p.fold_with(folder, binders));
Ok(Substitution::from_fallible(target_interner, folded)?)
}
}

Expand Down
Loading

0 comments on commit 1ac0d00

Please sign in to comment.