1 files changed, 150 insertions, 46 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 31ea45706..60c231e82 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -20,6 +20,7 @@ mod tests;
 pub(crate) mod method_resolution;
 
 use std::borrow::Cow;
+use std::iter::repeat;
 use std::ops::Index;
 use std::sync::Arc;
 use std::{fmt, mem};
@@ -33,7 +34,7 @@ use test_utils::tested_by;
 
 use crate::{
     Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
-    FnSignature, FnScopes, ModuleDef, AdtDef,
+    FnSignature, ExprScopes, ModuleDef, AdtDef,
     db::HirDatabase,
     type_ref::{TypeRef, Mutability},
     name::KnownName,
@@ -185,7 +186,7 @@ pub enum Ty {
 
     /// Structures, enumerations and unions.
     Adt {
-        /// The DefId of the struct/enum.
+        /// The definition of the struct/enum.
         def_id: AdtDef,
         /// The name, for displaying.
         name: Name,
@@ -209,6 +210,27 @@ pub enum Ty {
     /// `&'a mut T` or `&'a T`.
     Ref(Arc<Ty>, Mutability),
 
+    /// The anonymous type of a function declaration/definition. Each
+    /// function has a unique type, which is output (for a function
+    /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
+    ///
+    /// For example the type of `bar` here:
+    ///
+    /// ```rust
+    /// fn foo() -> i32 { 1 }
+    /// let bar = foo; // bar: fn() -> i32 {foo}
+    /// ```
+    FnDef {
+        // Function definition
+        def: Function,
+        /// For display
+        name: Name,
+        /// Parameters and return type
+        sig: Arc<FnSig>,
+        /// Substitutions for the generic parameters of the type
+        substs: Substs,
+    },
+
     /// A pointer to a function.  Written as `fn() -> i32`.
     ///
     /// For example the type of `bar` here:
@@ -448,12 +470,12 @@ impl Ty {
         }
         // add placeholders for args that were not provided
         // TODO: handle defaults
-        for _ in segment
+        let supplied_params = segment
             .args_and_bindings
             .as_ref()
             .map(|ga| ga.args.len())
-            .unwrap_or(0)..def_generics.params.len()
-        {
+            .unwrap_or(0);
+        for _ in supplied_params..def_generics.params.len() {
             substs.push(Ty::Unknown);
         }
         assert_eq!(substs.len(), def_generics.params.len());
@@ -485,6 +507,19 @@ impl Ty {
                 }
                 sig_mut.output.walk_mut(f);
             }
+            Ty::FnDef { substs, sig, .. } => {
+                let sig_mut = Arc::make_mut(sig);
+                for input in &mut sig_mut.input {
+                    input.walk_mut(f);
+                }
+                sig_mut.output.walk_mut(f);
+                // Without an Arc::make_mut_slice, we can't avoid the clone here:
+                let mut v: Vec<_> = substs.0.iter().cloned().collect();
+                for t in &mut v {
+                    t.walk_mut(f);
+                }
+                substs.0 = v.into();
+            }
             Ty::Adt { substs, .. } => {
                 // Without an Arc::make_mut_slice, we can't avoid the clone here:
                 let mut v: Vec<_> = substs.0.iter().cloned().collect();
@@ -524,6 +559,12 @@ impl Ty {
                 name,
                 substs,
             },
+            Ty::FnDef { def, name, sig, .. } => Ty::FnDef {
+                def,
+                name,
+                sig,
+                substs,
+            },
             _ => self,
         }
     }
@@ -551,7 +592,7 @@ impl Ty {
     /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
     fn substs(&self) -> Option<Substs> {
         match self {
-            Ty::Adt { substs, .. } => Some(substs.clone()),
+            Ty::Adt { substs, .. } | Ty::FnDef { substs, .. } => Some(substs.clone()),
             _ => None,
         }
     }
@@ -586,6 +627,22 @@ impl fmt::Display for Ty {
                     .to_fmt(f)?;
                 write!(f, " -> {}", sig.output)
             }
+            Ty::FnDef {
+                name, substs, sig, ..
+            } => {
+                write!(f, "fn {}", name)?;
+                if substs.0.len() > 0 {
+                    join(substs.0.iter())
+                        .surround_with("<", ">")
+                        .separator(", ")
+                        .to_fmt(f)?;
+                }
+                join(sig.input.iter())
+                    .surround_with("(", ")")
+                    .separator(", ")
+                    .to_fmt(f)?;
+                write!(f, " -> {}", sig.output)
+            }
             Ty::Adt { name, substs, .. } => {
                 write!(f, "{}", name)?;
                 if substs.0.len() > 0 {
@@ -607,11 +664,11 @@ impl fmt::Display for Ty {
 
 /// Compute the declared type of a function. This should not need to look at the
 /// function body.
-fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
-    let signature = f.signature(db);
-    let module = f.module(db);
-    let impl_block = f.impl_block(db);
-    let generics = f.generic_params(db);
+fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
+    let signature = def.signature(db);
+    let module = def.module(db);
+    let impl_block = def.impl_block(db);
+    let generics = def.generic_params(db);
     let input = signature
         .params()
         .iter()
@@ -624,8 +681,15 @@ fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
         &generics,
         signature.ret_type(),
     );
-    let sig = FnSig { input, output };
-    Ty::FnPtr(Arc::new(sig))
+    let sig = Arc::new(FnSig { input, output });
+    let substs = make_substs(&generics);
+    let name = def.name(db);
+    Ty::FnDef {
+        def,
+        sig,
+        name,
+        substs,
+    }
 }
 
 fn make_substs(generics: &GenericParams) -> Substs {
@@ -750,7 +814,7 @@ impl Index<PatId> for InferenceResult {
 struct InferenceContext<'a, D: HirDatabase> {
     db: &'a D,
     body: Arc<Body>,
-    scopes: Arc<FnScopes>,
+    scopes: Arc<ExprScopes>,
     module: Module,
     impl_block: Option<ImplBlock>,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
@@ -844,7 +908,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     fn new(
         db: &'a D,
         body: Arc<Body>,
-        scopes: Arc<FnScopes>,
+        scopes: Arc<ExprScopes>,
         module: Module,
         impl_block: Option<ImplBlock>,
     ) -> Self {
@@ -1102,7 +1166,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             .into();
         let typable = typable?;
         let ty = self.db.type_for_def(typable);
+        let generics = GenericParams::default();
+        let substs = Ty::substs_from_path(
+            self.db,
+            &self.module,
+            self.impl_block.as_ref(),
+            &generics,
+            path,
+            typable,
+        );
+        let ty = ty.apply_substs(substs);
         let ty = self.insert_type_vars(ty);
+
         Some(ty)
     }
 
@@ -1142,7 +1217,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
                 (ty, Some(var.into()))
             }
-            TypableDef::Enum(_) | TypableDef::Function(_) => (Ty::Unknown, None),
+            TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None),
         }
     }
 
@@ -1196,9 +1271,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     Ty::Tuple(ref tuple_args) => &**tuple_args,
                     _ => &[],
                 };
-                let expectations_iter = expectations
-                    .into_iter()
-                    .chain(std::iter::repeat(&Ty::Unknown));
+                let expectations_iter = expectations.into_iter().chain(repeat(&Ty::Unknown));
 
                 let inner_tys = args
                     .iter()
@@ -1332,18 +1405,25 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::Call { callee, args } => {
                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
                 let (param_tys, ret_ty) = match &callee_ty {
-                    Ty::FnPtr(sig) => (&sig.input[..], sig.output.clone()),
+                    Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()),
+                    Ty::FnDef { substs, sig, .. } => {
+                        let ret_ty = sig.output.clone().subst(&substs);
+                        let param_tys = sig
+                            .input
+                            .iter()
+                            .map(|ty| ty.clone().subst(&substs))
+                            .collect();
+                        (param_tys, ret_ty)
+                    }
                     _ => {
                         // not callable
                         // TODO report an error?
-                        (&[][..], Ty::Unknown)
+                        (Vec::new(), Ty::Unknown)
                     }
                 };
-                for (i, arg) in args.iter().enumerate() {
-                    self.infer_expr(
-                        *arg,
-                        &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    );
+                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
+                for (arg, param) in args.iter().zip(param_iter) {
+                    self.infer_expr(*arg, &Expectation::has_type(param));
                 }
                 ret_ty
             }
@@ -1365,21 +1445,34 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
                     Ty::FnPtr(sig) => {
                         if sig.input.len() > 0 {
-                            (&sig.input[0], &sig.input[1..], sig.output.clone())
+                            (
+                                sig.input[0].clone(),
+                                sig.input[1..].iter().cloned().collect(),
+                                sig.output.clone(),
+                            )
+                        } else {
+                            (Ty::Unknown, Vec::new(), sig.output.clone())
+                        }
+                    }
+                    Ty::FnDef { substs, sig, .. } => {
+                        let ret_ty = sig.output.clone().subst(&substs);
+
+                        if sig.input.len() > 0 {
+                            let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs));
+                            let receiver_ty = arg_iter.next().unwrap();
+                            (receiver_ty, arg_iter.collect(), ret_ty)
                         } else {
-                            (&Ty::Unknown, &[][..], sig.output.clone())
+                            (Ty::Unknown, Vec::new(), ret_ty)
                         }
                     }
-                    _ => (&Ty::Unknown, &[][..], Ty::Unknown),
+                    _ => (Ty::Unknown, Vec::new(), Ty::Unknown),
                 };
                 // TODO we would have to apply the autoderef/autoref steps here
                 // to get the correct receiver type to unify...
-                self.unify(expected_receiver_ty, &receiver_ty);
-                for (i, arg) in args.iter().enumerate() {
-                    self.infer_expr(
-                        *arg,
-                        &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    );
+                self.unify(&expected_receiver_ty, &receiver_ty);
+                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
+                for (arg, param) in args.iter().zip(param_iter) {
+                    self.infer_expr(*arg, &Expectation::has_type(param));
                 }
                 ret_ty
             }
@@ -1395,7 +1488,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     for &pat in &arm.pats {
                         let _pat_ty = self.infer_pat(pat, &input_ty);
                     }
-                    // TODO type the guard
+                    if let Some(guard_expr) = arm.guard {
+                        self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
+                    }
                     self.infer_expr(arm.expr, &expected);
                 }
 
@@ -1468,9 +1563,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 cast_ty
             }
             Expr::Ref { expr, mutability } => {
-                // TODO pass the expectation down
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty {
+                    if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                        // TODO: throw type error - expected mut reference but found shared ref,
+                        // which cannot be coerced
+                    }
+                    Expectation::has_type((**subty).clone())
+                } else {
+                    Expectation::none()
+                };
                 // TODO reference coercions etc.
+                let inner_ty = self.infer_expr(*expr, &expectation);
                 Ty::Ref(Arc::new(inner_ty), *mutability)
             }
             Expr::UnaryOp { expr, op } => {
@@ -1495,9 +1598,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             _ => Ty::Unknown,
                         }
                     }
-                    UnaryOp::Not if inner_ty == Ty::Bool => Ty::Bool,
-                    // TODO: resolve ops::Not trait for inner_ty
-                    UnaryOp::Not => Ty::Unknown,
+                    UnaryOp::Not => {
+                        match inner_ty {
+                            Ty::Bool | Ty::Int(_) | Ty::Infer(InferTy::IntVar(..)) => inner_ty,
+                            // TODO: resolve ops::Not trait for inner_ty
+                            _ => Ty::Unknown,
+                        }
+                    }
                 }
             }
             Expr::BinaryOp { lhs, rhs, op } => match op {
@@ -1609,10 +1716,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
             self.infer_pat(*pat, &ty);
         }
-        self.return_ty = {
-            let ty = self.make_ty(signature.ret_type());
-            ty
-        };
+        self.return_ty = self.make_ty(signature.ret_type());
     }
 
     fn infer_body(&mut self) {
@@ -1626,7 +1730,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
     db.check_canceled();
     let body = func.body(db);
-    let scopes = db.fn_scopes(func);
+    let scopes = db.expr_scopes(func);
     let module = func.module(db);
     let impl_block = func.impl_block(db);
     let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);