1 files changed, 115 insertions, 28 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 1b3525011..859bdfb3b 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,5 +1,5 @@
 //! FIXME: write short doc here
-use std::sync::Arc;
+use std::{iter, sync::Arc};
 
 use arrayvec::ArrayVec;
 use either::Either;
@@ -12,6 +12,7 @@ use hir_def::{
     import_map,
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
+    src::HasSource as _,
     type_ref::{Mutability, TypeRef},
     AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
     ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId,
@@ -25,21 +26,22 @@ use hir_expand::{
 use hir_ty::{
     autoderef,
     display::{HirDisplayError, HirFormatter},
-    expr::ExprValidator,
-    method_resolution,
-    unsafe_validation::UnsafeValidator,
-    ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs, TraitEnvironment, Ty,
-    TyDefId, TypeCtor,
+    method_resolution, ApplicationTy, CallableDefId, Canonical, FnSig, GenericPredicate,
+    InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
-use ra_syntax::ast::{self, AttrsOwner, NameOwner};
+use ra_syntax::{
+    ast::{self, AttrsOwner, NameOwner},
+    AstNode,
+};
 use rustc_hash::FxHashSet;
+use stdx::impl_from;
 
 use crate::{
     db::{DefDatabase, HirDatabase},
     has_source::HasSource,
-    CallableDef, HirDisplay, InFile, Name,
+    HirDisplay, InFile, Name,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -139,8 +141,8 @@ pub enum ModuleDef {
     TypeAlias(TypeAlias),
     BuiltinType(BuiltinType),
 }
-impl_froms!(
-    ModuleDef: Module,
+impl_from!(
+    Module,
     Function,
     Adt(Struct, Enum, Union),
     EnumVariant,
@@ -149,6 +151,7 @@ impl_froms!(
     Trait,
     TypeAlias,
     BuiltinType
+    for ModuleDef
 );
 
 impl ModuleDef {
@@ -538,7 +541,7 @@ pub enum Adt {
     Union(Union),
     Enum(Enum),
 }
-impl_froms!(Adt: Struct, Union, Enum);
+impl_from!(Struct, Union, Enum for Adt);
 
 impl Adt {
     pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
@@ -581,7 +584,7 @@ pub enum VariantDef {
     Union(Union),
     EnumVariant(EnumVariant),
 }
-impl_froms!(VariantDef: Struct, Union, EnumVariant);
+impl_from!(Struct, Union, EnumVariant for VariantDef);
 
 impl VariantDef {
     pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@@ -624,8 +627,7 @@ pub enum DefWithBody {
     Static(Static),
     Const(Const),
 }
-
-impl_froms!(DefWithBody: Function, Const, Static);
+impl_from!(Function, Const, Static for DefWithBody);
 
 impl DefWithBody {
     pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -676,13 +678,7 @@ impl Function {
     }
 
     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
-        let _p = profile("Function::diagnostics");
-        let infer = db.infer(self.id.into());
-        infer.add_diagnostics(db, self.id, sink);
-        let mut validator = ExprValidator::new(self.id, infer.clone(), sink);
-        validator.validate_body(db);
-        let mut validator = UnsafeValidator::new(self.id, infer, sink);
-        validator.validate_body(db);
+        hir_ty::diagnostics::validate_body(db, self.id.into(), sink)
     }
 }
 
@@ -927,14 +923,15 @@ pub enum GenericDef {
     // consts can have type parameters from their parents (i.e. associated consts of traits)
     Const(Const),
 }
-impl_froms!(
-    GenericDef: Function,
+impl_from!(
+    Function,
     Adt(Struct, Enum, Union),
     Trait,
     TypeAlias,
     ImplDef,
     EnumVariant,
     Const
+    for GenericDef
 );
 
 impl GenericDef {
@@ -955,6 +952,16 @@ pub struct Local {
 }
 
 impl Local {
+    pub fn is_param(self, db: &dyn HirDatabase) -> bool {
+        let src = self.source(db);
+        match src.value {
+            Either::Left(bind_pat) => {
+                bind_pat.syntax().ancestors().any(|it| ast::Param::can_cast(it.kind()))
+            }
+            Either::Right(_self_param) => true,
+        }
+    }
+
     // FIXME: why is this an option? It shouldn't be?
     pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
         let body = db.body(self.parent.into());
@@ -1162,6 +1169,12 @@ impl Type {
         Type::new(db, krate, def, ty)
     }
 
+    pub fn is_unit(&self) -> bool {
+        matches!(
+            self.ty.value,
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::Tuple { cardinality: 0 }, .. })
+        )
+    }
     pub fn is_bool(&self) -> bool {
         matches!(self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. }))
     }
@@ -1219,9 +1232,14 @@ impl Type {
         db.trait_solve(self.krate, goal).is_some()
     }
 
-    // FIXME: this method is broken, as it doesn't take closures into account.
-    pub fn as_callable(&self) -> Option<CallableDef> {
-        Some(self.ty.value.as_callable()?.0)
+    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
+        let def = match self.ty.value {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(def), parameters: _ }) => Some(def),
+            _ => None,
+        };
+
+        let sig = self.ty.value.callable_sig(db)?;
+        Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
     }
 
     pub fn is_closure(&self) -> bool {
@@ -1506,6 +1524,74 @@ impl HirDisplay for Type {
     }
 }
 
+// FIXME: closures
+#[derive(Debug)]
+pub struct Callable {
+    ty: Type,
+    sig: FnSig,
+    def: Option<CallableDefId>,
+    pub(crate) is_bound_method: bool,
+}
+
+pub enum CallableKind {
+    Function(Function),
+    TupleStruct(Struct),
+    TupleEnumVariant(EnumVariant),
+    Closure,
+}
+
+impl Callable {
+    pub fn kind(&self) -> CallableKind {
+        match self.def {
+            Some(CallableDefId::FunctionId(it)) => CallableKind::Function(it.into()),
+            Some(CallableDefId::StructId(it)) => CallableKind::TupleStruct(it.into()),
+            Some(CallableDefId::EnumVariantId(it)) => CallableKind::TupleEnumVariant(it.into()),
+            None => CallableKind::Closure,
+        }
+    }
+    pub fn receiver_param(&self, db: &dyn HirDatabase) -> Option<ast::SelfParam> {
+        let func = match self.def {
+            Some(CallableDefId::FunctionId(it)) if self.is_bound_method => it,
+            _ => return None,
+        };
+        let src = func.lookup(db.upcast()).source(db.upcast());
+        let param_list = src.value.param_list()?;
+        param_list.self_param()
+    }
+    pub fn n_params(&self) -> usize {
+        self.sig.params().len() - if self.is_bound_method { 1 } else { 0 }
+    }
+    pub fn params(
+        &self,
+        db: &dyn HirDatabase,
+    ) -> Vec<(Option<Either<ast::SelfParam, ast::Pat>>, Type)> {
+        let types = self
+            .sig
+            .params()
+            .iter()
+            .skip(if self.is_bound_method { 1 } else { 0 })
+            .map(|ty| self.ty.derived(ty.clone()));
+        let patterns = match self.def {
+            Some(CallableDefId::FunctionId(func)) => {
+                let src = func.lookup(db.upcast()).source(db.upcast());
+                src.value.param_list().map(|param_list| {
+                    param_list
+                        .self_param()
+                        .map(|it| Some(Either::Left(it)))
+                        .filter(|_| !self.is_bound_method)
+                        .into_iter()
+                        .chain(param_list.params().map(|it| it.pat().map(Either::Right)))
+                })
+            }
+            _ => None,
+        };
+        patterns.into_iter().flatten().chain(iter::repeat(None)).zip(types).collect()
+    }
+    pub fn return_type(&self) -> Type {
+        self.ty.derived(self.sig.ret().clone())
+    }
+}
+
 /// For IDE only
 #[derive(Debug)]
 pub enum ScopeDef {
@@ -1565,8 +1651,8 @@ pub enum AttrDef {
     MacroDef(MacroDef),
 }
 
-impl_froms!(
-    AttrDef: Module,
+impl_from!(
+    Module,
     Field,
     Adt(Struct, Enum, Union),
     EnumVariant,
@@ -1576,6 +1662,7 @@ impl_froms!(
     Trait,
     TypeAlias,
     MacroDef
+    for AttrDef
 );
 
 pub trait HasAttrs {