From bfbc210bc1216b79e355eb70449caf08dc67d5ad Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Fri, 22 May 2020 18:15:53 +0200 Subject: Use Chalk's built-in representation of function item types --- crates/ra_hir_ty/src/traits/chalk.rs | 39 ++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index e2f2a9ccb..5b0f12a3c 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -14,7 +14,7 @@ use ra_db::{salsa::InternKey, CrateId}; use super::{builtin, AssocTyValue, ChalkContext, Impl}; use crate::{ db::HirDatabase, display::HirDisplay, method_resolution::TyFingerprint, utils::generics, - DebruijnIndex, GenericPredicate, Substs, Ty, TypeCtor, + CallableDef, DebruijnIndex, GenericPredicate, Substs, Ty, TypeCtor, }; use chalk_rust_ir::WellKnownTrait; use mapping::{convert_where_clauses, generic_predicate_to_inline_bound, make_binders}; @@ -54,10 +54,9 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { fn fn_def_datum( &self, - _fn_def_id: chalk_ir::FnDefId, + fn_def_id: chalk_ir::FnDefId, ) -> Arc> { - // We don't yet provide any FnDefs to Chalk - unimplemented!() + self.db.fn_def_datum(self.krate, fn_def_id) } fn impls_for_trait( @@ -405,6 +404,26 @@ fn type_alias_associated_ty_value( Arc::new(value) } +pub(crate) fn fn_def_datum_query( + db: &dyn HirDatabase, + _krate: CrateId, + fn_def_id: FnDefId, +) -> Arc { + let callable_def: CallableDef = from_chalk(db, fn_def_id); + let generic_params = generics(db.upcast(), callable_def.into()); + let sig = db.callable_item_signature(callable_def); + let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST); + let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars); + let bound = chalk_rust_ir::FnDefDatumBound { + // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway + argument_types: sig.value.params().iter().map(|ty| ty.clone().to_chalk(db)).collect(), + return_type: sig.value.ret().clone().to_chalk(db), + where_clauses, + }; + let datum = FnDefDatum { id: fn_def_id, binders: make_binders(bound, sig.num_binders) }; + Arc::new(datum) +} + impl From for crate::TypeCtorId { fn from(struct_id: AdtId) -> Self { struct_id.0 @@ -417,6 +436,18 @@ impl From for AdtId { } } +impl From for crate::CallableDefId { + fn from(fn_def_id: FnDefId) -> Self { + InternKey::from_intern_id(fn_def_id.0) + } +} + +impl From for FnDefId { + fn from(callable_def_id: crate::CallableDefId) -> Self { + chalk_ir::FnDefId(callable_def_id.as_intern_id()) + } +} + impl From for crate::traits::GlobalImplId { fn from(impl_id: ImplId) -> Self { InternKey::from_intern_id(impl_id.0) -- cgit v1.2.3 From c8a4bb1445e214dc7105de547bd999ad270e7b42 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Wed, 27 May 2020 21:05:21 +0200 Subject: Upgrade Chalk Chalk newly added TypeName::Never and Array; I implemented the conversion for Never, but not Array since that expects a const argument. --- crates/ra_hir_ty/src/traits/chalk.rs | 50 ++++++++++++++++++------------------ 1 file changed, 25 insertions(+), 25 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index 5b0f12a3c..61de3cc30 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -4,6 +4,7 @@ use std::sync::Arc; use log::debug; use chalk_ir::{fold::shift::Shift, GenericArg, TypeName}; +use chalk_solve::rust_ir::{self, WellKnownTrait}; use hir_def::{ lang_item::{lang_attr, LangItemTarget}, @@ -16,7 +17,6 @@ use crate::{ db::HirDatabase, display::HirDisplay, method_resolution::TyFingerprint, utils::generics, CallableDef, DebruijnIndex, GenericPredicate, Substs, Ty, TypeCtor, }; -use chalk_rust_ir::WellKnownTrait; use mapping::{convert_where_clauses, generic_predicate_to_inline_bound, make_binders}; pub use self::interner::*; @@ -55,7 +55,7 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { fn fn_def_datum( &self, fn_def_id: chalk_ir::FnDefId, - ) -> Arc> { + ) -> Arc> { self.db.fn_def_datum(self.krate, fn_def_id) } @@ -112,7 +112,7 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { } fn well_known_trait_id( &self, - well_known_trait: chalk_rust_ir::WellKnownTrait, + well_known_trait: rust_ir::WellKnownTrait, ) -> Option> { let lang_attr = lang_attr_from_well_known_trait(well_known_trait); let lang_items = self.db.crate_lang_items(self.krate); @@ -133,13 +133,13 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { fn opaque_ty_data( &self, _id: chalk_ir::OpaqueTyId, - ) -> Arc> { + ) -> Arc> { unimplemented!() } fn force_impl_for( &self, - _well_known: chalk_rust_ir::WellKnownTrait, + _well_known: rust_ir::WellKnownTrait, _ty: &chalk_ir::TyData, ) -> Option { // this method is mostly for rustc @@ -150,6 +150,10 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { // FIXME: implement actual object safety true } + + fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId) -> chalk_ir::Ty { + Ty::Unknown.to_chalk(self.db) + } } pub(crate) fn program_clauses_for_chalk_env_query( @@ -188,7 +192,7 @@ pub(crate) fn associated_ty_data_query( .collect(); let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars); - let bound_data = chalk_rust_ir::AssociatedTyDatumBound { bounds, where_clauses }; + let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses }; let datum = AssociatedTyDatum { trait_id: trait_.to_chalk(db), id, @@ -209,7 +213,7 @@ pub(crate) fn trait_datum_query( debug!("trait {:?} = {:?}", trait_id, trait_data.name); let generic_params = generics(db.upcast(), trait_.into()); let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST); - let flags = chalk_rust_ir::TraitFlags { + let flags = rust_ir::TraitFlags { auto: trait_data.auto, upstream: trait_.lookup(db.upcast()).container.module(db.upcast()).krate != krate, non_enumerable: true, @@ -221,7 +225,7 @@ pub(crate) fn trait_datum_query( let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); let associated_ty_ids = trait_data.associated_types().map(|type_alias| type_alias.to_chalk(db)).collect(); - let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses }; + let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; let well_known = lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name)); let trait_datum = TraitDatum { @@ -271,12 +275,12 @@ pub(crate) fn struct_datum_query( convert_where_clauses(db, generic_def, &bound_vars) }) .unwrap_or_else(Vec::new); - let flags = chalk_rust_ir::AdtFlags { + let flags = rust_ir::AdtFlags { upstream, // FIXME set fundamental flag correctly fundamental: false, }; - let struct_datum_bound = chalk_rust_ir::AdtDatumBound { + let struct_datum_bound = rust_ir::AdtDatumBound { fields: Vec::new(), // FIXME add fields (only relevant for auto traits) where_clauses, }; @@ -316,9 +320,9 @@ fn impl_def_datum( let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST); let trait_ = trait_ref.trait_; let impl_type = if impl_id.lookup(db.upcast()).container.module(db.upcast()).krate == krate { - chalk_rust_ir::ImplType::Local + rust_ir::ImplType::Local } else { - chalk_rust_ir::ImplType::External + rust_ir::ImplType::External }; let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars); let negative = impl_data.is_negative; @@ -331,13 +335,9 @@ fn impl_def_datum( ); let trait_ref = trait_ref.to_chalk(db); - let polarity = if negative { - chalk_rust_ir::Polarity::Negative - } else { - chalk_rust_ir::Polarity::Positive - }; + let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive }; - let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses }; + let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses }; let trait_data = db.trait_data(trait_); let associated_ty_value_ids = impl_data .items @@ -395,8 +395,8 @@ fn type_alias_associated_ty_value( .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 = db.ty(type_alias.into()); - let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; - let value = chalk_rust_ir::AssociatedTyValue { + let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; + let value = rust_ir::AssociatedTyValue { impl_id: Impl::ImplDef(impl_id).to_chalk(db), associated_ty_id: assoc_ty.to_chalk(db), value: make_binders(value_bound, ty.num_binders), @@ -414,7 +414,7 @@ pub(crate) fn fn_def_datum_query( let sig = db.callable_item_signature(callable_def); let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST); let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars); - let bound = chalk_rust_ir::FnDefDatumBound { + 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 argument_types: sig.value.params().iter().map(|ty| ty.clone().to_chalk(db)).collect(), return_type: sig.value.ret().clone().to_chalk(db), @@ -460,14 +460,14 @@ impl From for ImplId { } } -impl From> for crate::traits::AssocTyValueId { - fn from(id: chalk_rust_ir::AssociatedTyValueId) -> Self { +impl From> for crate::traits::AssocTyValueId { + fn from(id: rust_ir::AssociatedTyValueId) -> Self { Self::from_intern_id(id.0) } } -impl From for chalk_rust_ir::AssociatedTyValueId { +impl From for rust_ir::AssociatedTyValueId { fn from(assoc_ty_value_id: crate::traits::AssocTyValueId) -> Self { - chalk_rust_ir::AssociatedTyValueId(assoc_ty_value_id.as_intern_id()) + rust_ir::AssociatedTyValueId(assoc_ty_value_id.as_intern_id()) } } -- cgit v1.2.3