use rustc_hash::FxHashSet;
use super::{builder::ClauseBuilder, generalize};
use crate::RustIrDatabase;
use chalk_ir::{
cast::Cast, fold::shift::Shift, interner::Interner, Binders, BoundVar, DebruijnIndex, TraitId,
TraitRef, Ty, TyKind, WhereClause,
};
pub(super) fn build_dyn_self_ty_clauses<I: Interner>(
db: &dyn RustIrDatabase<I>,
builder: &mut ClauseBuilder<'_, I>,
self_ty: Ty<I>,
) {
let interner = db.interner();
let dyn_ty = match self_ty.kind(interner) {
TyKind::Dyn(dyn_ty) => dyn_ty,
_ => return,
};
let generalized_dyn_ty = generalize::Generalize::apply(db.interner(), dyn_ty);
builder.push_binders(&generalized_dyn_ty, |builder, dyn_ty| {
for exists_qwc in dyn_ty.bounds.map_ref(|r| r.iter(interner)) {
let qwc = exists_qwc.substitute(interner, &[self_ty.clone().cast(interner)]);
builder.push_binders(&qwc, |builder, wc| match &wc {
WhereClause::Implemented(trait_ref) => {
push_dyn_ty_impl_clauses(db, builder, trait_ref.clone())
}
WhereClause::AliasEq(_) => builder.push_fact(wc),
WhereClause::LifetimeOutlives(..) => {}
WhereClause::TypeOutlives(..) => {}
});
}
});
}
fn push_dyn_ty_impl_clauses<I: Interner>(
db: &dyn RustIrDatabase<I>,
builder: &mut ClauseBuilder<'_, I>,
trait_ref: TraitRef<I>,
) {
let interner = db.interner();
let super_trait_refs =
super_traits(db, trait_ref.trait_id).substitute(interner, &trait_ref.substitution);
for q_super_trait_ref in super_trait_refs {
builder.push_binders(&q_super_trait_ref, |builder, super_trait_ref| {
let trait_datum = db.trait_datum(super_trait_ref.trait_id);
let wc = trait_datum
.where_clauses()
.substitute(interner, &super_trait_ref.substitution);
builder.push_clause(super_trait_ref, wc);
});
}
}
pub fn super_traits<I: Interner>(
db: &dyn RustIrDatabase<I>,
trait_id: TraitId<I>,
) -> Binders<Vec<Binders<TraitRef<I>>>> {
let interner = db.interner();
let mut seen_traits = FxHashSet::default();
let trait_datum = db.trait_datum(trait_id);
let trait_ref = Binders::empty(
db.interner(),
TraitRef {
trait_id,
substitution: trait_datum
.binders
.identity_substitution(interner)
.shifted_in(interner),
},
);
let mut trait_refs = Vec::new();
go(db, trait_ref, &mut seen_traits, &mut trait_refs);
fn go<I: Interner>(
db: &dyn RustIrDatabase<I>,
trait_ref: Binders<TraitRef<I>>,
seen_traits: &mut FxHashSet<TraitId<I>>,
trait_refs: &mut Vec<Binders<TraitRef<I>>>,
) {
let interner = db.interner();
let trait_id = trait_ref.skip_binders().trait_id;
if !seen_traits.insert(trait_id) {
return;
}
trait_refs.push(trait_ref.clone());
let trait_datum = db.trait_datum(trait_id);
let super_trait_refs = trait_datum
.binders
.map_ref(|td| {
td.where_clauses
.iter()
.filter_map(|qwc| {
qwc.as_ref().filter_map(|wc| match wc {
WhereClause::Implemented(tr) => {
let self_ty = tr.self_type_parameter(db.interner());
if self_ty.bound_var(db.interner())
!= Some(BoundVar::new(DebruijnIndex::ONE, 0))
{
return None;
}
Some(tr.clone())
}
WhereClause::AliasEq(_) => None,
WhereClause::LifetimeOutlives(..) => None,
WhereClause::TypeOutlives(..) => None,
})
})
.collect::<Vec<_>>()
})
.substitute(db.interner(), &trait_ref.skip_binders().substitution);
for q_super_trait_ref in super_trait_refs {
let actual_binders = Binders::new(trait_ref.binders.clone(), q_super_trait_ref);
let q_super_trait_ref = actual_binders.fuse_binders(interner);
go(db, q_super_trait_ref, seen_traits, trait_refs);
}
seen_traits.remove(&trait_id);
}
Binders::new(trait_datum.binders.binders.clone(), trait_refs)
}