From 089b1c57c1774eb1aacec53828ce2d2648adff2d Mon Sep 17 00:00:00 2001 From: Marcus Klaas de Vries Date: Sat, 26 Jan 2019 12:06:41 +0100 Subject: Address some issues flagged in review --- crates/ra_hir/src/code_model_api.rs | 11 ++----- crates/ra_hir/src/code_model_impl/function.rs | 10 +++---- crates/ra_hir/src/ty.rs | 43 +++++++++++---------------- 3 files changed, 25 insertions(+), 39 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index a13da58d2..e4008058c 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -388,8 +388,7 @@ pub use crate::code_model_impl::function::ScopeEntryWithSyntax; #[derive(Debug, Clone, PartialEq, Eq)] pub struct FnSignature { pub(crate) name: Name, - pub(crate) type_params: Arc, - pub(crate) args: Vec, + pub(crate) params: Vec, pub(crate) ret_type: TypeRef, /// True if the first param is `self`. This is relevant to decide whether this /// can be called as a method. @@ -401,8 +400,8 @@ impl FnSignature { &self.name } - pub fn args(&self) -> &[TypeRef] { - &self.args + pub fn params(&self) -> &[TypeRef] { + &self.params } pub fn ret_type(&self) -> &TypeRef { @@ -414,10 +413,6 @@ impl FnSignature { pub fn has_self_param(&self) -> bool { self.has_self_param } - - pub fn generics(&self) -> &GenericParams { - &self.type_params - } } impl Function { diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs index f4beab6ae..e0dd4d629 100644 --- a/crates/ra_hir/src/code_model_impl/function.rs +++ b/crates/ra_hir/src/code_model_impl/function.rs @@ -32,7 +32,7 @@ impl FnSignature { .name() .map(|n| n.as_name()) .unwrap_or_else(Name::missing); - let mut args = Vec::new(); + let mut params = Vec::new(); let mut has_self_param = false; if let Some(param_list) = node.param_list() { if let Some(self_param) = param_list.self_param() { @@ -50,15 +50,14 @@ impl FnSignature { } } }; - args.push(self_type); + params.push(self_type); has_self_param = true; } for param in param_list.params() { let type_ref = TypeRef::from_ast_opt(param.type_ref()); - args.push(type_ref); + params.push(type_ref); } } - let type_params = db.generic_params(func.into()); let ret_type = if let Some(type_ref) = node.ret_type().and_then(|rt| rt.type_ref()) { TypeRef::from_ast(type_ref) } else { @@ -67,8 +66,7 @@ impl FnSignature { let sig = FnSignature { name, - type_params, - args, + params, ret_type, has_self_param, }; diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index 43181ffc9..3cf3eaded 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -34,7 +34,7 @@ use test_utils::tested_by; use crate::{ Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock, - FnSignature, FnScopes, ModuleDef, AdtDef, + FnScopes, ModuleDef, AdtDef, db::HirDatabase, type_ref::{TypeRef, Mutability}, name::KnownName, @@ -1164,13 +1164,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(var.into())) } - TypableDef::Function(func) => { - let ty = type_for_fn(self.db, func); - let ty = self.insert_type_vars(ty.apply_substs(substs)); - // FIXME: is this right? - (ty, None) - } - TypableDef::Enum(_) => (Ty::Unknown, None), + TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None), } } @@ -1363,15 +1357,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), Ty::FnDef { def, substs, .. } => { let fn_sig = def.signature(self.db); + let generic_params = def.generic_params(self.db); let ret_ty = self - .make_ty(fn_sig.ret_type(), fn_sig.generics()) + .make_ty(fn_sig.ret_type(), &generic_params) .subst(&substs); let param_tys = fn_sig - .args() + .params() .iter() - .map(|type_ref| { - self.make_ty(type_ref, fn_sig.generics()).subst(&substs) - }) + .map(|type_ref| self.make_ty(type_ref, &generic_params).subst(&substs)) .collect(); (param_tys, ret_ty) } @@ -1416,13 +1409,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } Ty::FnDef { def, substs, .. } => { let fn_sig = def.signature(self.db); + let generic_params = def.generic_params(self.db); let ret_ty = self - .make_ty(fn_sig.ret_type(), fn_sig.generics()) + .make_ty(fn_sig.ret_type(), &generic_params) .subst(&substs); - if fn_sig.args().len() > 0 { - let mut arg_iter = fn_sig.args().iter().map(|type_ref| { - self.make_ty(type_ref, fn_sig.generics()).subst(&substs) + if fn_sig.params().len() > 0 { + let mut arg_iter = fn_sig.params().iter().map(|type_ref| { + self.make_ty(type_ref, &generic_params).subst(&substs) }); let receiver_ty = arg_iter.next().unwrap(); (receiver_ty, arg_iter.collect(), ret_ty) @@ -1660,15 +1654,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { ty } - fn collect_fn_signature(&mut self, signature: &FnSignature) { + fn collect_fn_signature(&mut self, func: Function) { let body = Arc::clone(&self.body); // avoid borrow checker problem - let generics = signature.generics(); - for (type_ref, pat) in signature.args().iter().zip(body.params()) { - let ty = self.make_ty(type_ref, generics); + let signature = func.signature(self.db); + let generics = func.generic_params(self.db); + for (type_ref, pat) in signature.params().iter().zip(body.params()) { + let ty = self.make_ty(type_ref, &generics); self.infer_pat(*pat, &ty); } - self.return_ty = self.make_ty(signature.ret_type(), generics); + self.return_ty = self.make_ty(signature.ret_type(), &generics); } fn infer_body(&mut self) { @@ -1687,9 +1682,7 @@ pub fn infer(db: &impl HirDatabase, func: Function) -> Arc { let impl_block = func.impl_block(db); let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block); - let signature = func.signature(db); - ctx.collect_fn_signature(&signature); - + ctx.collect_fn_signature(func); ctx.infer_body(); Arc::new(ctx.resolve_all()) -- cgit v1.2.3