Remove a bunch of stuff from chalk_db

7 files changed, 80 insertions, 513 deletions

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
index f523a5e8bfa..546991cf657 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
@@ -1,44 +1,13 @@
 //! The implementation of `RustIrDatabase` for Chalk, which provides information
 //! about the code that Chalk needs.
-use std::sync::Arc;
+use hir_def::{CallableDefId, GenericDefId};
 
-use tracing::debug;
-
-use chalk_ir::{cast::Caster, fold::shift::Shift};
-use chalk_solve::rust_ir::{self, WellKnownTrait};
-
-use base_db::Crate;
-use hir_def::{
-    AssocItemId, CallableDefId, GenericDefId, HasModule, ItemContainerId, Lookup, TypeAliasId,
-    VariantId,
-    lang_item::LangItem,
-    signatures::{ImplFlags, StructFlags, TraitFlags},
-};
-
-use crate::{
-    AliasEq, AliasTy, DebruijnIndex, Interner, ProjectionTyExt, QuantifiedWhereClause,
-    Substitution, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
-    db::HirDatabase,
-    from_assoc_type_id, from_chalk_trait_id,
-    generics::generics,
-    lower::LifetimeElisionKind,
-    make_binders,
-    mapping::{ToChalk, TypeAliasAsValue, from_chalk},
-    to_assoc_type_id, to_chalk_trait_id,
-};
-
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-pub(crate) type AdtDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+use crate::{Interner, Substitution, db::HirDatabase, mapping::from_chalk};
 
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
 pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
 pub(crate) type Variances = chalk_ir::Variances<Interner>;
 
 impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
@@ -54,340 +23,6 @@ impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
     }
 }
 
-pub(crate) fn associated_ty_data_query(
-    db: &dyn HirDatabase,
-    type_alias: TypeAliasId,
-) -> Arc<AssociatedTyDatum> {
-    debug!("associated_ty_data {:?}", type_alias);
-    let trait_ = match type_alias.lookup(db).container {
-        ItemContainerId::TraitId(t) => t,
-        _ => panic!("associated type not in trait"),
-    };
-
-    // Lower bounds -- we could/should maybe move this to a separate query in `lower`
-    let type_alias_data = db.type_alias_signature(type_alias);
-    let generic_params = generics(db, type_alias.into());
-    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
-    let mut ctx = crate::TyLoweringContext::new(
-        db,
-        &resolver,
-        &type_alias_data.store,
-        type_alias.into(),
-        LifetimeElisionKind::AnonymousReportError,
-    )
-    .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
-
-    let trait_subst = TyBuilder::subst_for_def(db, trait_, None)
-        .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
-        .build();
-    let pro_ty = TyBuilder::assoc_type_projection(db, type_alias, Some(trait_subst))
-        .fill_with_bound_vars(
-            crate::DebruijnIndex::INNERMOST,
-            generic_params.parent_generics().map_or(0, |it| it.len()),
-        )
-        .build();
-    let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);
-
-    let mut bounds = Vec::new();
-    for bound in &type_alias_data.bounds {
-        ctx.lower_type_bound(bound, self_ty.clone(), false).for_each(|pred| {
-            if let Some(pred) = generic_predicate_to_inline_bound(db, &pred, &self_ty) {
-                bounds.push(pred);
-            }
-        });
-    }
-
-    if !ctx.unsized_types.contains(&self_ty) {
-        let sized_trait =
-            LangItem::Sized.resolve_trait(db, resolver.krate()).map(to_chalk_trait_id);
-        let sized_bound = sized_trait.into_iter().map(|sized_trait| {
-            let trait_bound =
-                rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
-            let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
-            chalk_ir::Binders::empty(Interner, inline_bound)
-        });
-        bounds.extend(sized_bound);
-        bounds.shrink_to_fit();
-    }
-
-    // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
-    //        (rust-analyzer#9052)
-    // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
-    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
-    let datum = AssociatedTyDatum {
-        trait_id: to_chalk_trait_id(trait_),
-        id: to_assoc_type_id(type_alias),
-        name: type_alias,
-        binders: make_binders(db, &generic_params, bound_data),
-    };
-    Arc::new(datum)
-}
-
-pub(crate) fn trait_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    trait_id: TraitId,
-) -> Arc<TraitDatum> {
-    debug!("trait_datum {:?}", trait_id);
-    let trait_ = from_chalk_trait_id(trait_id);
-    let trait_data = db.trait_signature(trait_);
-    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
-    let generic_params = generics(db, trait_.into());
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let flags = rust_ir::TraitFlags {
-        auto: trait_data.flags.contains(TraitFlags::AUTO),
-        upstream: trait_.lookup(db).container.krate() != krate,
-        non_enumerable: true,
-        coinductive: false, // only relevant for Chalk testing
-        // FIXME: set these flags correctly
-        marker: false,
-        fundamental: trait_data.flags.contains(TraitFlags::FUNDAMENTAL),
-    };
-    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
-    let associated_ty_ids =
-        trait_.trait_items(db).associated_types().map(to_assoc_type_id).collect();
-    let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
-    let well_known = db.lang_attr(trait_.into()).and_then(well_known_trait_from_lang_item);
-    let trait_datum = TraitDatum {
-        id: trait_id,
-        binders: make_binders(db, &generic_params, trait_datum_bound),
-        flags,
-        associated_ty_ids,
-        well_known,
-    };
-    Arc::new(trait_datum)
-}
-
-fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
-    Some(match item {
-        LangItem::Clone => WellKnownTrait::Clone,
-        LangItem::CoerceUnsized => WellKnownTrait::CoerceUnsized,
-        LangItem::Copy => WellKnownTrait::Copy,
-        LangItem::DiscriminantKind => WellKnownTrait::DiscriminantKind,
-        LangItem::DispatchFromDyn => WellKnownTrait::DispatchFromDyn,
-        LangItem::Drop => WellKnownTrait::Drop,
-        LangItem::Fn => WellKnownTrait::Fn,
-        LangItem::FnMut => WellKnownTrait::FnMut,
-        LangItem::FnOnce => WellKnownTrait::FnOnce,
-        LangItem::AsyncFn => WellKnownTrait::AsyncFn,
-        LangItem::AsyncFnMut => WellKnownTrait::AsyncFnMut,
-        LangItem::AsyncFnOnce => WellKnownTrait::AsyncFnOnce,
-        LangItem::Coroutine => WellKnownTrait::Coroutine,
-        LangItem::Sized => WellKnownTrait::Sized,
-        LangItem::Unpin => WellKnownTrait::Unpin,
-        LangItem::Unsize => WellKnownTrait::Unsize,
-        LangItem::Tuple => WellKnownTrait::Tuple,
-        LangItem::PointeeTrait => WellKnownTrait::Pointee,
-        LangItem::FnPtrTrait => WellKnownTrait::FnPtr,
-        LangItem::Future => WellKnownTrait::Future,
-        _ => return None,
-    })
-}
-
-pub(crate) fn adt_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    chalk_ir::AdtId(adt_id): AdtId,
-) -> Arc<AdtDatum> {
-    debug!("adt_datum {:?}", adt_id);
-    let generic_params = generics(db, adt_id.into());
-    let bound_vars_subst = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let where_clauses = convert_where_clauses(db, adt_id.into(), &bound_vars_subst);
-
-    let (fundamental, phantom_data) = match adt_id {
-        hir_def::AdtId::StructId(s) => {
-            let flags = db.struct_signature(s).flags;
-            (flags.contains(StructFlags::FUNDAMENTAL), flags.contains(StructFlags::IS_PHANTOM_DATA))
-        }
-        // FIXME set fundamental flags correctly
-        hir_def::AdtId::UnionId(_) => (false, false),
-        hir_def::AdtId::EnumId(_) => (false, false),
-    };
-    let flags = rust_ir::AdtFlags {
-        upstream: adt_id.module(db).krate() != krate,
-        fundamental,
-        phantom_data,
-    };
-
-    // this slows down rust-analyzer by quite a bit unfortunately, so enabling this is currently not worth it
-    let _variant_id_to_fields = |id: VariantId| {
-        let variant_data = &id.fields(db);
-        let fields = if variant_data.fields().is_empty() {
-            vec![]
-        } else {
-            let field_types = db.field_types(id);
-            variant_data
-                .fields()
-                .iter()
-                .map(|(idx, _)| field_types[idx].clone().substitute(Interner, &bound_vars_subst))
-                .filter(|it| !it.contains_unknown())
-                .collect()
-        };
-        rust_ir::AdtVariantDatum { fields }
-    };
-    let variant_id_to_fields = |_: VariantId| rust_ir::AdtVariantDatum { fields: vec![] };
-
-    let (kind, variants) = match adt_id {
-        hir_def::AdtId::StructId(id) => {
-            (rust_ir::AdtKind::Struct, vec![variant_id_to_fields(id.into())])
-        }
-        hir_def::AdtId::EnumId(id) => {
-            let variants = id
-                .enum_variants(db)
-                .variants
-                .iter()
-                .map(|&(variant_id, _, _)| variant_id_to_fields(variant_id.into()))
-                .collect();
-            (rust_ir::AdtKind::Enum, variants)
-        }
-        hir_def::AdtId::UnionId(id) => {
-            (rust_ir::AdtKind::Union, vec![variant_id_to_fields(id.into())])
-        }
-    };
-
-    let struct_datum_bound = rust_ir::AdtDatumBound { variants, where_clauses };
-    let struct_datum = AdtDatum {
-        kind,
-        id: chalk_ir::AdtId(adt_id),
-        binders: make_binders(db, &generic_params, struct_datum_bound),
-        flags,
-    };
-    Arc::new(struct_datum)
-}
-
-pub(crate) fn impl_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    impl_id: ImplId,
-) -> Arc<ImplDatum> {
-    let _p = tracing::info_span!("impl_datum_query").entered();
-    debug!("impl_datum {:?}", impl_id);
-    let impl_: hir_def::ImplId = from_chalk(db, impl_id);
-    impl_def_datum(db, krate, impl_)
-}
-
-fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId) -> Arc<ImplDatum> {
-    let trait_ref = db
-        .impl_trait(impl_id)
-        // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
-        .expect("invalid impl passed to Chalk")
-        .into_value_and_skipped_binders()
-        .0;
-    let impl_data = db.impl_signature(impl_id);
-
-    let generic_params = generics(db, impl_id.into());
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let trait_ = trait_ref.hir_trait_id();
-    let impl_type = if impl_id.lookup(db).container.krate() == krate {
-        rust_ir::ImplType::Local
-    } else {
-        rust_ir::ImplType::External
-    };
-    let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
-    let negative = impl_data.flags.contains(ImplFlags::NEGATIVE);
-    let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
-
-    let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
-    let trait_data = trait_.trait_items(db);
-    let associated_ty_value_ids = impl_id
-        .impl_items(db)
-        .items
-        .iter()
-        .filter_map(|(_, item)| match item {
-            AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
-            _ => None,
-        })
-        .filter(|&type_alias| {
-            // don't include associated types that don't exist in the trait
-            let name = &db.type_alias_signature(type_alias).name;
-            trait_data.associated_type_by_name(name).is_some()
-        })
-        .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
-        .collect();
-    debug!("impl_datum: {:?}", impl_datum_bound);
-    let impl_datum = ImplDatum {
-        binders: make_binders(db, &generic_params, impl_datum_bound),
-        impl_type,
-        polarity,
-        associated_ty_value_ids,
-    };
-    Arc::new(impl_datum)
-}
-
-pub(crate) fn associated_ty_value_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    id: AssociatedTyValueId,
-) -> Arc<AssociatedTyValue> {
-    let type_alias: TypeAliasAsValue = from_chalk(db, id);
-    type_alias_associated_ty_value(db, krate, type_alias.0)
-}
-
-fn type_alias_associated_ty_value(
-    db: &dyn HirDatabase,
-    _krate: Crate,
-    type_alias: TypeAliasId,
-) -> Arc<AssociatedTyValue> {
-    let type_alias_data = db.type_alias_signature(type_alias);
-    let impl_id = match type_alias.lookup(db).container {
-        ItemContainerId::ImplId(it) => it,
-        _ => panic!("assoc ty value should be in impl"),
-    };
-
-    let trait_ref = db
-        .impl_trait(impl_id)
-        .expect("assoc ty value should not exist")
-        .into_value_and_skipped_binders()
-        .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
-
-    let assoc_ty = trait_ref
-        .hir_trait_id()
-        .trait_items(db)
-        .associated_type_by_name(&type_alias_data.name)
-        .expect("assoc ty value should not exist"); // validated when building the impl data as well
-    let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
-    let value_bound = rust_ir::AssociatedTyValueBound { ty };
-    let value = rust_ir::AssociatedTyValue {
-        impl_id: impl_id.to_chalk(db),
-        associated_ty_id: to_assoc_type_id(assoc_ty),
-        value: chalk_ir::Binders::new(binders, value_bound),
-    };
-    Arc::new(value)
-}
-
-pub(crate) fn fn_def_datum_query(
-    db: &dyn HirDatabase,
-    callable_def: CallableDefId,
-) -> Arc<FnDefDatum> {
-    let generic_def = GenericDefId::from_callable(db, callable_def);
-    let generic_params = generics(db, generic_def);
-    let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let where_clauses = convert_where_clauses(db, generic_def, &bound_vars);
-    let bound = rust_ir::FnDefDatumBound {
-        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
-        inputs_and_output: chalk_ir::Binders::empty(
-            Interner,
-            rust_ir::FnDefInputsAndOutputDatum {
-                argument_types: sig.params().to_vec(),
-                return_type: sig.ret().clone(),
-            }
-            .shifted_in(Interner),
-        ),
-        where_clauses,
-    };
-    let datum = FnDefDatum {
-        id: callable_def.to_chalk(db),
-        sig: chalk_ir::FnSig {
-            abi: sig.abi,
-            safety: chalk_ir::Safety::Safe,
-            variadic: sig.is_varargs,
-        },
-        binders: chalk_ir::Binders::new(binders, bound),
-    };
-    Arc::new(datum)
-}
-
 pub(crate) fn fn_def_variance_query(
     db: &dyn HirDatabase,
     callable_def: CallableDefId,
@@ -431,59 +66,3 @@ pub(super) fn convert_where_clauses(
         .map(|pred| pred.substitute(Interner, substs))
         .collect()
 }
-
-pub(super) fn generic_predicate_to_inline_bound(
-    db: &dyn HirDatabase,
-    pred: &QuantifiedWhereClause,
-    self_ty: &Ty,
-) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
-    // An InlineBound is like a GenericPredicate, except the self type is left out.
-    // We don't have a special type for this, but Chalk does.
-    let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
-    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
-    match pred {
-        WhereClause::Implemented(trait_ref) => {
-            if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
-                // we can only convert predicates back to type bounds if they
-                // have the expected self type
-                return None;
-            }
-            let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
-                .iter()
-                .cloned()
-                .casted(Interner)
-                .collect();
-            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
-        }
-        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            let generics = generics(db, from_assoc_type_id(projection_ty.associated_ty_id).into());
-            let parent_len = generics.parent_generics().map_or(0, |g| g.len_self());
-            let (trait_args, assoc_args) =
-                projection_ty.substitution.as_slice(Interner).split_at(parent_len);
-            let (self_ty, args_no_self) =
-                trait_args.split_first().expect("projection without trait self type");
-            if self_ty.assert_ty_ref(Interner) != &self_ty_shifted_in {
-                return None;
-            }
-
-            let args_no_self = args_no_self.iter().cloned().casted(Interner).collect();
-            let parameters = assoc_args.to_vec();
-
-            let alias_eq_bound = rust_ir::AliasEqBound {
-                value: ty.clone(),
-                trait_bound: rust_ir::TraitBound {
-                    trait_id: to_chalk_trait_id(projection_ty.trait_(db)),
-                    args_no_self,
-                },
-                associated_ty_id: projection_ty.associated_ty_id,
-                parameters,
-            };
-            Some(chalk_ir::Binders::new(
-                binders,
-                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
-            ))
-        }
-        _ => None,
-    }
-}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 9affd3b48c5..97754f47233 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -1,8 +1,6 @@
 //! The home of `HirDatabase`, which is the Salsa database containing all the
 //! type inference-related queries.
 
-use std::sync;
-
 use base_db::Crate;
 use hir_def::{
     AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
@@ -240,26 +238,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::interned]
     fn intern_coroutine(&self, id: InternedCoroutine) -> InternedCoroutineId;
 
-    #[salsa::invoke(chalk_db::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: TypeAliasId) -> sync::Arc<chalk_db::AssociatedTyDatum>;
-
-    #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(
-        &self,
-        krate: Crate,
-        trait_id: chalk_db::TraitId,
-    ) -> sync::Arc<chalk_db::TraitDatum>;
-
-    #[salsa::invoke(chalk_db::adt_datum_query)]
-    fn adt_datum(&self, krate: Crate, struct_id: chalk_db::AdtId) -> sync::Arc<chalk_db::AdtDatum>;
-
-    #[salsa::invoke(chalk_db::impl_datum_query)]
-    fn impl_datum(&self, krate: Crate, impl_id: chalk_db::ImplId)
-    -> sync::Arc<chalk_db::ImplDatum>;
-
-    #[salsa::invoke(chalk_db::fn_def_datum_query)]
-    fn fn_def_datum(&self, fn_def_id: CallableDefId) -> sync::Arc<chalk_db::FnDefDatum>;
-
     #[salsa::invoke(chalk_db::fn_def_variance_query)]
     fn fn_def_variance(&self, fn_def_id: CallableDefId) -> chalk_db::Variances;
 
@@ -274,13 +252,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     )]
     fn variances_of(&self, def: GenericDefId) -> Option<Arc<[crate::variance::Variance]>>;
 
-    #[salsa::invoke(chalk_db::associated_ty_value_query)]
-    fn associated_ty_value(
-        &self,
-        krate: Crate,
-        id: chalk_db::AssociatedTyValueId,
-    ) -> sync::Arc<chalk_db::AssociatedTyValue>;
-
     #[salsa::invoke(crate::traits::normalize_projection_query)]
     #[salsa::transparent]
     fn normalize_projection(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
index b26bd2b8fa9..403ea05a4f5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
@@ -5,7 +5,6 @@
 use std::fmt;
 
 use base_db::Crate;
-use chalk_solve::rust_ir::AdtKind;
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, DefWithBodyId, HasModule, ItemContainerId, Lookup,
@@ -300,11 +299,7 @@ impl ExprValidator {
                 value_or_partial.is_none_or(|v| !matches!(v, ValueNs::StaticId(_)))
             }
             Expr::Field { expr, .. } => match self.infer.type_of_expr[*expr].kind(Interner) {
-                TyKind::Adt(adt, ..)
-                    if db.adt_datum(self.owner.krate(db), *adt).kind == AdtKind::Union =>
-                {
-                    false
-                }
+                TyKind::Adt(adt, ..) if matches!(adt.0, AdtId::UnionId(_)) => false,
                 _ => self.is_known_valid_scrutinee(*expr, db),
             },
             Expr::Index { base, .. } => self.is_known_valid_scrutinee(*base, db),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index f0a4167f8e2..09b983a580d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -1,12 +1,12 @@
 //! Type cast logic. Basically coercion + additional casts.
 
 use chalk_ir::{Mutability, Scalar, TyVariableKind, UintTy};
-use hir_def::{AdtId, hir::ExprId};
+use hir_def::{AdtId, hir::ExprId, signatures::TraitFlags};
 use stdx::never;
 
 use crate::{
     Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,
-    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,
+    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause, from_chalk_trait_id,
     infer::{coerce::CoerceNever, unify::InferenceTable},
 };
 
@@ -290,10 +290,12 @@ impl CastCheck {
                             return Ok(());
                         }
                         let src_principal =
-                            table.db.trait_datum(table.trait_env.krate, src_principal);
+                            table.db.trait_signature(from_chalk_trait_id(src_principal));
                         let dst_principal =
-                            table.db.trait_datum(table.trait_env.krate, dst_principal);
-                        if src_principal.is_auto_trait() && dst_principal.is_auto_trait() {
+                            table.db.trait_signature(from_chalk_trait_id(dst_principal));
+                        if src_principal.flags.contains(TraitFlags::AUTO)
+                            && dst_principal.flags.contains(TraitFlags::AUTO)
+                        {
                             Ok(())
                         } else {
                             Err(CastError::DifferingKinds)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index d8fc20e8741..38ac2e11707 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -9,7 +9,6 @@ use chalk_ir::{
     visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
 };
 use either::Either;
-use hir_def::Lookup;
 use hir_def::{
     DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,
     expr_store::path::Path,
@@ -22,6 +21,7 @@ use hir_def::{
     resolver::ValueNs,
     type_ref::TypeRefId,
 };
+use hir_def::{ItemContainerId, Lookup, TraitId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -30,16 +30,16 @@ use stdx::{format_to, never};
 use syntax::utils::is_raw_identifier;
 
 use crate::{
-    Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ChalkTraitId, ClosureId, DynTy,
-    DynTyExt, FnAbi, FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt,
-    Substitution, Ty, TyBuilder, TyExt, WhereClause,
+    Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ClosureId, DynTy, DynTyExt, FnAbi,
+    FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt, Substitution, Ty,
+    TyBuilder, TyExt, WhereClause,
     db::{HirDatabase, InternedClosure, InternedCoroutine},
     error_lifetime, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,
     generics::Generics,
     infer::{BreakableKind, CoerceMany, Diverges, coerce::CoerceNever},
     make_binders,
     mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},
-    to_assoc_type_id, to_chalk_trait_id,
+    to_assoc_type_id,
     traits::FnTrait,
     utils::{self, elaborate_clause_supertraits},
 };
@@ -321,10 +321,8 @@ impl InferenceContext<'_> {
     fn deduce_sig_from_dyn_ty(&self, dyn_ty: &DynTy) -> Option<FnPointer> {
         // Search for a predicate like `<$self as FnX<Args>>::Output == Ret`
 
-        let fn_traits: SmallVec<[ChalkTraitId; 3]> =
-            utils::fn_traits(self.db, self.owner.module(self.db).krate())
-                .map(to_chalk_trait_id)
-                .collect();
+        let fn_traits: SmallVec<[TraitId; 3]> =
+            utils::fn_traits(self.db, self.owner.module(self.db).krate()).collect();
 
         let self_ty = self.result.standard_types.unknown.clone();
         let bounds = dyn_ty.bounds.clone().substitute(Interner, &[self_ty.cast(Interner)]);
@@ -333,9 +331,13 @@ impl InferenceContext<'_> {
             if let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) =
                 bound.skip_binders()
             {
-                let assoc_data =
-                    self.db.associated_ty_data(from_assoc_type_id(projection.associated_ty_id));
-                if !fn_traits.contains(&assoc_data.trait_id) {
+                let trait_ =
+                    match from_assoc_type_id(projection.associated_ty_id).lookup(self.db).container
+                    {
+                        ItemContainerId::TraitId(t) => t,
+                        _ => panic!("associated type not in trait"),
+                    };
+                if !fn_traits.contains(&trait_) {
                     return None;
                 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
index 9d3d2044c43..448fbdf6736 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
@@ -3,8 +3,6 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_solve::rust_ir;
-
 use hir_def::{LifetimeParamId, TraitId, TypeAliasId, TypeOrConstParamId};
 use salsa::{
     Id,
@@ -54,23 +52,6 @@ impl ToChalk for CallableDefId {
     }
 }
 
-pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
-
-impl ToChalk for TypeAliasAsValue {
-    type Chalk = chalk_db::AssociatedTyValueId;
-
-    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId {
-        rust_ir::AssociatedTyValueId(self.0.as_id())
-    }
-
-    fn from_chalk(
-        _db: &dyn HirDatabase,
-        assoc_ty_value_id: chalk_db::AssociatedTyValueId,
-    ) -> TypeAliasAsValue {
-        TypeAliasAsValue(TypeAliasId::from_id(assoc_ty_value_id.0))
-    }
-}
-
 impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
     fn from(id: OpaqueTyId) -> Self {
         FromId::from_id(id.0)
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index ff7d116dcce..f03f542e5bc 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -66,7 +66,7 @@ use hir_def::{
     },
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
-    signatures::{ImplFlags, StaticFlags, TraitFlags, VariantFields},
+    signatures::{ImplFlags, StaticFlags, StructFlags, TraitFlags, VariantFields},
     src::HasSource as _,
     visibility::visibility_from_ast,
 };
@@ -4945,42 +4945,79 @@ impl<'db> Type<'db> {
     }
 
     pub fn contains_reference(&self, db: &'db dyn HirDatabase) -> bool {
-        return go(db, self.env.krate, &self.ty);
+        return go(db, &self.ty);
 
-        fn go(db: &dyn HirDatabase, krate: base_db::Crate, ty: &Ty) -> bool {
+        fn is_phantom_data(db: &dyn HirDatabase, adt_id: AdtId) -> bool {
+            match adt_id {
+                hir_def::AdtId::StructId(s) => {
+                    let flags = db.struct_signature(s).flags;
+                    flags.contains(StructFlags::IS_PHANTOM_DATA)
+                }
+                hir_def::AdtId::UnionId(_) => false,
+                hir_def::AdtId::EnumId(_) => false,
+            }
+        }
+
+        fn go(db: &dyn HirDatabase, ty: &Ty) -> bool {
             match ty.kind(Interner) {
                 // Reference itself
                 TyKind::Ref(_, _, _) => true,
 
                 // For non-phantom_data adts we check variants/fields as well as generic parameters
-                TyKind::Adt(adt_id, substitution)
-                    if !db.adt_datum(krate, *adt_id).flags.phantom_data =>
-                {
-                    let adt_datum = &db.adt_datum(krate, *adt_id);
-                    let adt_datum_bound =
-                        adt_datum.binders.clone().substitute(Interner, substitution);
-                    adt_datum_bound
-                        .variants
+                TyKind::Adt(adt_id, substitution) if !is_phantom_data(db, adt_id.0) => {
+                    let _variant_id_to_fields = |id: VariantId| {
+                        let variant_data = &id.fields(db);
+                        if variant_data.fields().is_empty() {
+                            vec![]
+                        } else {
+                            let field_types = db.field_types(id);
+                            variant_data
+                                .fields()
+                                .iter()
+                                .map(|(idx, _)| {
+                                    field_types[idx].clone().substitute(Interner, substitution)
+                                })
+                                .filter(|it| !it.contains_unknown())
+                                .collect()
+                        }
+                    };
+                    let variant_id_to_fields = |_: VariantId| vec![];
+
+                    let variants = match adt_id.0 {
+                        hir_def::AdtId::StructId(id) => {
+                            vec![variant_id_to_fields(id.into())]
+                        }
+                        hir_def::AdtId::EnumId(id) => id
+                            .enum_variants(db)
+                            .variants
+                            .iter()
+                            .map(|&(variant_id, _, _)| variant_id_to_fields(variant_id.into()))
+                            .collect(),
+                        hir_def::AdtId::UnionId(id) => {
+                            vec![variant_id_to_fields(id.into())]
+                        }
+                    };
+
+                    variants
                         .into_iter()
-                        .flat_map(|variant| variant.fields.into_iter())
-                        .any(|ty| go(db, krate, &ty))
+                        .flat_map(|variant| variant.into_iter())
+                        .any(|ty| go(db, &ty))
                         || substitution
                             .iter(Interner)
                             .filter_map(|x| x.ty(Interner))
-                            .any(|ty| go(db, krate, ty))
+                            .any(|ty| go(db, ty))
                 }
                 // And for `PhantomData<T>`, we check `T`.
                 TyKind::Adt(_, substitution)
                 | TyKind::Tuple(_, substitution)
                 | TyKind::OpaqueType(_, substitution)
                 | TyKind::AssociatedType(_, substitution)
-                | TyKind::FnDef(_, substitution) => substitution
-                    .iter(Interner)
-                    .filter_map(|x| x.ty(Interner))
-                    .any(|ty| go(db, krate, ty)),
+                | TyKind::FnDef(_, substitution) => {
+                    substitution.iter(Interner).filter_map(|x| x.ty(Interner)).any(|ty| go(db, ty))
+                }
 
                 // For `[T]` or `*T` we check `T`
-                TyKind::Array(ty, _) | TyKind::Slice(ty) | TyKind::Raw(_, ty) => go(db, krate, ty),
+                TyKind::Array(ty, _) | TyKind::Slice(ty) | TyKind::Raw(_, ty) => go(db, ty),
 
                 // Consider everything else as not reference
                 _ => false,