bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat
-rw-r--r--crates/hir-ty/src/chalk_db.rs425
-rw-r--r--crates/hir-ty/src/db.rs29
-rw-r--r--crates/hir-ty/src/diagnostics/expr.rs7
-rw-r--r--crates/hir-ty/src/infer/cast.rs12
-rw-r--r--crates/hir-ty/src/infer/closure.rs26
-rw-r--r--crates/hir-ty/src/mapping.rs19
-rw-r--r--crates/hir/src/lib.rs75
7 files changed, 80 insertions, 513 deletions
diff --git a/crates/hir-ty/src/chalk_db.rs b/crates/hir-ty/src/chalk_db.rs
index f523a5e8bf..546991cf65 100644
--- a/crates/hir-ty/src/chalk_db.rs
+++ b/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/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
index 9affd3b48c..97754f4723 100644
--- a/crates/hir-ty/src/db.rs
+++ b/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/crates/hir-ty/src/diagnostics/expr.rs b/crates/hir-ty/src/diagnostics/expr.rs
index b26bd2b8fa..403ea05a4f 100644
--- a/crates/hir-ty/src/diagnostics/expr.rs
+++ b/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/crates/hir-ty/src/infer/cast.rs b/crates/hir-ty/src/infer/cast.rs
index f0a4167f8e..09b983a580 100644
--- a/crates/hir-ty/src/infer/cast.rs
+++ b/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/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index d8fc20e874..38ac2e1170 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/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/crates/hir-ty/src/mapping.rs b/crates/hir-ty/src/mapping.rs
index 9d3d2044c4..448fbdf673 100644
--- a/crates/hir-ty/src/mapping.rs
+++ b/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/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index ff7d116dcc..f03f542e5b 100644
--- a/crates/hir/src/lib.rs
+++ b/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,