From 4c43631829d8bac8b7533c994d8cf1241a95ce70 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 26 Nov 2019 14:35:23 +0300 Subject: Introduce hir_ty --- crates/ra_hir/src/ty/lower.rs | 34 +------- crates/ra_hir/src/ty/primitive.rs | 159 +------------------------------------- 2 files changed, 3 insertions(+), 190 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 485871e69..2d23890a5 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs @@ -9,7 +9,7 @@ use std::iter; use std::sync::Arc; use hir_def::{ - builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType}, + builtin_type::BuiltinType, generics::WherePredicate, path::{GenericArg, PathSegment}, resolver::{HasResolver, Resolver, TypeNs}, @@ -27,7 +27,7 @@ use super::{ use crate::{ db::HirDatabase, ty::{ - primitive::{FloatTy, IntTy, Uncertain}, + primitive::{FloatTy, IntTy}, Adt, }, util::make_mut_slice, @@ -679,36 +679,6 @@ fn type_for_builtin(def: BuiltinType) -> Ty { }) } -impl From for IntTy { - fn from(t: BuiltinInt) -> Self { - IntTy { signedness: t.signedness, bitness: t.bitness } - } -} - -impl From for FloatTy { - fn from(t: BuiltinFloat) -> Self { - FloatTy { bitness: t.bitness } - } -} - -impl From> for Uncertain { - fn from(t: Option) -> Self { - match t { - None => Uncertain::Unknown, - Some(t) => Uncertain::Known(t.into()), - } - } -} - -impl From> for Uncertain { - fn from(t: Option) -> Self { - match t { - None => Uncertain::Unknown, - Some(t) => Uncertain::Known(t.into()), - } - } -} - fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig { let struct_data = db.struct_data(def.into()); let fields = struct_data.variant_data.fields(); diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs index 47789db87..eb7b5c4ef 100644 --- a/crates/ra_hir/src/ty/primitive.rs +++ b/crates/ra_hir/src/ty/primitive.rs @@ -1,160 +1,3 @@ //! FIXME: write short doc here -use std::fmt; - -pub use hir_def::builtin_type::{FloatBitness, IntBitness, Signedness}; - -#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)] -pub enum Uncertain { - Unknown, - Known(T), -} - -impl From for Uncertain { - fn from(ty: IntTy) -> Self { - Uncertain::Known(ty) - } -} - -impl fmt::Display for Uncertain { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - Uncertain::Unknown => write!(f, "{{integer}}"), - Uncertain::Known(ty) => write!(f, "{}", ty), - } - } -} - -impl From for Uncertain { - fn from(ty: FloatTy) -> Self { - Uncertain::Known(ty) - } -} - -impl fmt::Display for Uncertain { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - Uncertain::Unknown => write!(f, "{{float}}"), - Uncertain::Known(ty) => write!(f, "{}", ty), - } - } -} - -#[derive(Copy, Clone, Eq, PartialEq, Hash)] -pub struct IntTy { - pub signedness: Signedness, - pub bitness: IntBitness, -} - -impl fmt::Debug for IntTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - -impl fmt::Display for IntTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.ty_to_string()) - } -} - -impl IntTy { - pub fn isize() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::Xsize } - } - - pub fn i8() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::X8 } - } - - pub fn i16() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::X16 } - } - - pub fn i32() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::X32 } - } - - pub fn i64() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::X64 } - } - - pub fn i128() -> IntTy { - IntTy { signedness: Signedness::Signed, bitness: IntBitness::X128 } - } - - pub fn usize() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize } - } - - pub fn u8() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X8 } - } - - pub fn u16() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X16 } - } - - pub fn u32() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X32 } - } - - pub fn u64() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X64 } - } - - pub fn u128() -> IntTy { - IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X128 } - } - - pub(crate) fn ty_to_string(self) -> &'static str { - match (self.signedness, self.bitness) { - (Signedness::Signed, IntBitness::Xsize) => "isize", - (Signedness::Signed, IntBitness::X8) => "i8", - (Signedness::Signed, IntBitness::X16) => "i16", - (Signedness::Signed, IntBitness::X32) => "i32", - (Signedness::Signed, IntBitness::X64) => "i64", - (Signedness::Signed, IntBitness::X128) => "i128", - (Signedness::Unsigned, IntBitness::Xsize) => "usize", - (Signedness::Unsigned, IntBitness::X8) => "u8", - (Signedness::Unsigned, IntBitness::X16) => "u16", - (Signedness::Unsigned, IntBitness::X32) => "u32", - (Signedness::Unsigned, IntBitness::X64) => "u64", - (Signedness::Unsigned, IntBitness::X128) => "u128", - } - } -} - -#[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub struct FloatTy { - pub bitness: FloatBitness, -} - -impl fmt::Debug for FloatTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - -impl fmt::Display for FloatTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.ty_to_string()) - } -} - -impl FloatTy { - pub fn f32() -> FloatTy { - FloatTy { bitness: FloatBitness::X32 } - } - - pub fn f64() -> FloatTy { - FloatTy { bitness: FloatBitness::X64 } - } - - pub(crate) fn ty_to_string(self) -> &'static str { - match self.bitness { - FloatBitness::X32 => "f32", - FloatBitness::X64 => "f64", - } - } -} +pub use hir_ty::primitive::{FloatBitness, IntBitness, Signedness, FloatTy, IntTy, Uncertain}; -- cgit v1.2.3 From 45d05ed78384b28fbd341068f36912a2e0308292 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 26 Nov 2019 15:27:33 +0300 Subject: id-ify impls_in_crate_query --- crates/ra_hir/src/code_model.rs | 9 +++ crates/ra_hir/src/db.rs | 4 +- crates/ra_hir/src/ty/method_resolution.rs | 101 ++++++++++++++++-------------- crates/ra_hir/src/ty/primitive.rs | 2 +- crates/ra_hir/src/ty/traits.rs | 4 +- 5 files changed, 69 insertions(+), 51 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index bb1596bed..821f919d4 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -997,6 +997,15 @@ pub struct ImplBlock { } impl ImplBlock { + pub fn all_in_crate(db: &impl HirDatabase, krate: Crate) -> Vec { + let impls = db.impls_in_crate(krate.crate_id); + impls.all_impls().map(Self::from).collect() + } + pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec { + let impls = db.impls_in_crate(krate.crate_id); + impls.lookup_impl_blocks_for_trait(trait_).map(Self::from).collect() + } + pub fn target_trait(&self, db: &impl DefDatabase) -> Option { db.impl_data(self.id).target_trait.clone() } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index b034d4e44..32f05a4d8 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use ra_arena::map::ArenaMap; -use ra_db::salsa; +use ra_db::{salsa, CrateId}; use crate::{ ty::{ @@ -60,7 +60,7 @@ pub trait HirDatabase: DefDatabase { fn generic_defaults(&self, def: GenericDefId) -> Substs; #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)] - fn impls_in_crate(&self, krate: Crate) -> Arc; + fn impls_in_crate(&self, krate: CrateId) -> Arc; #[salsa::invoke(crate::ty::traits::impls_for_trait_query)] fn impls_for_trait(&self, krate: Crate, trait_: Trait) -> Arc<[ImplBlock]>; diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index 7f0ff2e8c..489fcd64b 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -5,14 +5,19 @@ use std::sync::Arc; use arrayvec::ArrayVec; -use hir_def::{lang_item::LangItemTarget, resolver::Resolver, AstItemDef, HasModule}; +use hir_def::{ + lang_item::LangItemTarget, resolver::HasResolver, resolver::Resolver, AssocItemId, AstItemDef, + HasModule, ImplId, TraitId, +}; +use ra_db::CrateId; +use ra_prof::profile; use rustc_hash::FxHashMap; use crate::{ db::HirDatabase, ty::primitive::{FloatBitness, Uncertain}, ty::{Ty, TypeCtor}, - AssocItem, Crate, Function, ImplBlock, Module, Mutability, Name, Trait, + AssocItem, Crate, Function, Mutability, Name, Trait, }; use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef}; @@ -37,54 +42,58 @@ impl TyFingerprint { #[derive(Debug, PartialEq, Eq)] pub struct CrateImplBlocks { - impls: FxHashMap>, - impls_by_trait: FxHashMap>, + impls: FxHashMap>, + impls_by_trait: FxHashMap>, } impl CrateImplBlocks { pub(crate) fn impls_in_crate_query( db: &impl HirDatabase, - krate: Crate, + krate: CrateId, ) -> Arc { - let mut crate_impl_blocks = + let _p = profile("impls_in_crate_query"); + let mut res = CrateImplBlocks { impls: FxHashMap::default(), impls_by_trait: FxHashMap::default() }; - if let Some(module) = krate.root_module(db) { - crate_impl_blocks.collect_recursive(db, module); + + let crate_def_map = db.crate_def_map(krate); + for (_module_id, module_data) in crate_def_map.modules.iter() { + for &impl_id in module_data.impls.iter() { + let impl_data = db.impl_data(impl_id); + let resolver = impl_id.resolver(db); + + let target_ty = { Ty::from_hir(db, &resolver, &impl_data.target_type) }; + + match &impl_data.target_trait { + Some(trait_ref) => { + if let Some(tr) = + TraitRef::from_hir(db, &resolver, &trait_ref, Some(target_ty)) + { + res.impls_by_trait.entry(tr.trait_.id).or_default().push(impl_id); + } + } + None => { + if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) { + res.impls.entry(target_ty_fp).or_default().push(impl_id); + } + } + } + } } - Arc::new(crate_impl_blocks) + + Arc::new(res) } - pub fn lookup_impl_blocks(&self, ty: &Ty) -> impl Iterator + '_ { + pub fn lookup_impl_blocks(&self, ty: &Ty) -> impl Iterator + '_ { let fingerprint = TyFingerprint::for_impl(ty); fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied() } - pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator + '_ { - self.impls_by_trait.get(&tr).into_iter().flatten().copied() + pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator + '_ { + self.impls_by_trait.get(&tr.id).into_iter().flatten().copied() } - pub fn all_impls<'a>(&'a self) -> impl Iterator + 'a { + pub fn all_impls<'a>(&'a self) -> impl Iterator + 'a { self.impls.values().chain(self.impls_by_trait.values()).flatten().copied() } - - fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) { - for impl_block in module.impl_blocks(db) { - let target_ty = impl_block.target_ty(db); - - if impl_block.target_trait(db).is_some() { - if let Some(tr) = impl_block.target_trait_ref(db) { - self.impls_by_trait.entry(tr.trait_).or_default().push(impl_block); - } - } else { - if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) { - self.impls.entry(target_ty_fp).or_default().push(impl_block); - } - } - } - - for child in module.children(db) { - self.collect_recursive(db, child); - } - } } fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option> { @@ -279,14 +288,14 @@ fn iterate_inherent_methods( mut callback: impl FnMut(&Ty, AssocItem) -> Option, ) -> Option { for krate in def_crates(db, krate, &ty.value)? { - let impls = db.impls_in_crate(krate); + let impls = db.impls_in_crate(krate.crate_id); for impl_block in impls.lookup_impl_blocks(&ty.value) { - for item in impl_block.items(db) { + for &item in db.impl_data(impl_block).items.iter() { if !is_valid_candidate(db, name, mode, item) { continue; } - if let Some(result) = callback(&ty.value, item) { + if let Some(result) = callback(&ty.value, item.into()) { return Some(result); } } @@ -299,17 +308,17 @@ fn is_valid_candidate( db: &impl HirDatabase, name: Option<&Name>, mode: LookupMode, - item: AssocItem, + item: AssocItemId, ) -> bool { match item { - AssocItem::Function(m) => { - let data = db.function_data(m.id); - name.map_or(true, |name| data.name == *name) + AssocItemId::FunctionId(m) => { + let data = db.function_data(m); + name.map_or(true, |name| &data.name == name) && (data.has_self_param || mode == LookupMode::Path) } - AssocItem::Const(c) => { - name.map_or(true, |name| Some(name) == c.name(db).as_ref()) - && (mode == LookupMode::Path) + AssocItemId::ConstId(c) => { + let data = db.const_data(c); + name.map_or(true, |name| data.name.as_ref() == Some(name)) && (mode == LookupMode::Path) } _ => false, } @@ -344,11 +353,11 @@ impl Ty { mut callback: impl FnMut(AssocItem) -> Option, ) -> Option { for krate in def_crates(db, krate, &self)? { - let impls = db.impls_in_crate(krate); + let impls = db.impls_in_crate(krate.crate_id); for impl_block in impls.lookup_impl_blocks(&self) { - for item in impl_block.items(db) { - if let Some(result) = callback(item) { + for &item in db.impl_data(impl_block).items.iter() { + if let Some(result) = callback(item.into()) { return Some(result); } } diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs index eb7b5c4ef..12dc96572 100644 --- a/crates/ra_hir/src/ty/primitive.rs +++ b/crates/ra_hir/src/ty/primitive.rs @@ -1,3 +1,3 @@ //! FIXME: write short doc here -pub use hir_ty::primitive::{FloatBitness, IntBitness, Signedness, FloatTy, IntTy, Uncertain}; +pub use hir_ty::primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness, Uncertain}; diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs index b9a5d651f..2eeb03099 100644 --- a/crates/ra_hir/src/ty/traits.rs +++ b/crates/ra_hir/src/ty/traits.rs @@ -88,8 +88,8 @@ pub(crate) fn impls_for_trait_query( for dep in krate.dependencies(db) { impls.extend(db.impls_for_trait(dep.krate, trait_).iter()); } - let crate_impl_blocks = db.impls_in_crate(krate); - impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_)); + let crate_impl_blocks = db.impls_in_crate(krate.crate_id); + impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_).map(ImplBlock::from)); impls.into_iter().collect() } -- cgit v1.2.3