1 files changed, 127 insertions, 68 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 615a1caed..13ee6cb27 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -5,21 +5,17 @@ mod tests;
 use std::sync::Arc;
 use std::fmt;
 
+use log;
 use rustc_hash::{FxHashMap};
 
-use ra_db::LocalSyntaxPtr;
+use ra_db::{LocalSyntaxPtr, Cancelable};
 use ra_syntax::{
     SmolStr,
     ast::{self, AstNode, LoopBodyOwner, ArgListOwner},
     SyntaxNodeRef
 };
 
-use crate::{
-    FnScopes,
-    db::HirDatabase,
-};
-
-// pub(crate) type TypeId = Id<Ty>;
+use crate::{Def, DefId, FnScopes, Module, Function, Path, db::HirDatabase};
 
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub enum Ty {
@@ -65,18 +61,6 @@ pub enum Ty {
     /// `&'a mut T` or `&'a T`.
     // Ref(Region<'tcx>, Ty<'tcx>, hir::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(DefId, &'tcx Substs<'tcx>),
-
     /// A pointer to a function.  Written as `fn() -> i32`.
     ///
     /// For example the type of `bar` here:
@@ -85,7 +69,7 @@ pub enum Ty {
     /// fn foo() -> i32 { 1 }
     /// let bar: fn() -> i32 = foo;
     /// ```
-    // FnPtr(PolyFnSig<'tcx>),
+    FnPtr(Arc<FnSig>),
 
     /// A trait, defined with `trait`.
     // Dynamic(Binder<&'tcx List<ExistentialPredicate<'tcx>>>, ty::Region<'tcx>),
@@ -139,6 +123,12 @@ pub enum Ty {
 
 type TyRef = Arc<Ty>;
 
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct FnSig {
+    input: Vec<Ty>,
+    output: Ty,
+}
+
 impl Ty {
     pub fn new(node: ast::TypeRef) -> Self {
         use ra_syntax::ast::TypeRef::*;
@@ -208,11 +198,55 @@ impl fmt::Display for Ty {
                 }
                 write!(f, ")")
             }
+            Ty::FnPtr(sig) => {
+                write!(f, "fn(")?;
+                for t in &sig.input {
+                    write!(f, "{},", t)?;
+                }
+                write!(f, ") -> {}", sig.output)
+            }
             Ty::Unknown => write!(f, "[unknown]"),
         }
     }
 }
 
+pub fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
+    eprintln!("type_for_fn {:?}", f.fn_id);
+    let syntax = f.syntax(db);
+    let node = syntax.borrowed();
+    // TODO we ignore type parameters for now
+    let input = node
+        .param_list()
+        .map(|pl| {
+            pl.params()
+                .map(|p| p.type_ref().map(|t| Ty::new(t)).unwrap_or(Ty::Unknown))
+                .collect()
+        })
+        .unwrap_or_else(Vec::new);
+    let output = node
+        .ret_type()
+        .and_then(|rt| rt.type_ref())
+        .map(|t| Ty::new(t))
+        .unwrap_or(Ty::Unknown);
+    let sig = FnSig { input, output };
+    Ok(Ty::FnPtr(Arc::new(sig)))
+}
+
+pub fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
+    let def = def_id.resolve(db)?;
+    match def {
+        Def::Module(..) => {
+            log::debug!("trying to get type for module {:?}", def_id);
+            Ok(Ty::Unknown)
+        }
+        Def::Function(f) => type_for_fn(db, f),
+        Def::Item => {
+            log::debug!("trying to get type for item of unknown type {:?}", def_id);
+            Ok(Ty::Unknown)
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
     type_for: FxHashMap<LocalSyntaxPtr, Ty>,
@@ -224,18 +258,22 @@ impl InferenceResult {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct InferenceContext {
+#[derive(Clone, Debug)]
+pub struct InferenceContext<'a, D: HirDatabase> {
+    db: &'a D,
     scopes: Arc<FnScopes>,
+    module: Module,
     // TODO unification tables...
     type_for: FxHashMap<LocalSyntaxPtr, Ty>,
 }
 
-impl InferenceContext {
-    fn new(scopes: Arc<FnScopes>) -> Self {
+impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+    fn new(db: &'a D, scopes: Arc<FnScopes>, module: Module) -> Self {
         InferenceContext {
             type_for: FxHashMap::default(),
+            db,
             scopes,
+            module,
         }
     }
 
@@ -262,36 +300,42 @@ impl InferenceContext {
         self.unify(ty1, ty2)
     }
 
-    fn infer_path_expr(&mut self, expr: ast::PathExpr) -> Option<Ty> {
-        let p = expr.path()?;
-        if p.qualifier().is_none() {
-            let name = p.segment().and_then(|s| s.name_ref())?;
-            let scope_entry = self.scopes.resolve_local_name(name)?;
-            let ty = self.type_for.get(&scope_entry.ptr())?;
-            Some(ty.clone())
-        } else {
-            // TODO resolve path
-            Some(Ty::Unknown)
-        }
+    fn infer_path_expr(&mut self, expr: ast::PathExpr) -> Cancelable<Option<Ty>> {
+        let ast_path = ctry!(expr.path());
+        let path = ctry!(Path::from_ast(ast_path));
+        if path.is_ident() {
+            // resolve locally
+            let name = ctry!(ast_path.segment().and_then(|s| s.name_ref()));
+            if let Some(scope_entry) = self.scopes.resolve_local_name(name) {
+                let ty = ctry!(self.type_for.get(&scope_entry.ptr()));
+                return Ok(Some(ty.clone()));
+            };
+        };
+
+        // resolve in module
+        let resolved = ctry!(self.module.resolve_path(self.db, path)?);
+        let ty = self.db.type_for_def(resolved)?;
+        // TODO we will need to add type variables for type parameters etc. here
+        Ok(Some(ty))
     }
 
-    fn infer_expr(&mut self, expr: ast::Expr) -> Ty {
+    fn infer_expr(&mut self, expr: ast::Expr) -> Cancelable<Ty> {
         let ty = match expr {
             ast::Expr::IfExpr(e) => {
                 if let Some(condition) = e.condition() {
                     if let Some(e) = condition.expr() {
                         // TODO if no pat, this should be bool
-                        self.infer_expr(e);
+                        self.infer_expr(e)?;
                     }
                     // TODO write type for pat
                 };
                 let if_ty = if let Some(block) = e.then_branch() {
-                    self.infer_block(block)
+                    self.infer_block(block)?
                 } else {
                     Ty::Unknown
                 };
                 let else_ty = if let Some(block) = e.else_branch() {
-                    self.infer_block(block)
+                    self.infer_block(block)?
                 } else {
                     Ty::Unknown
                 };
@@ -304,14 +348,14 @@ impl InferenceContext {
             }
             ast::Expr::BlockExpr(e) => {
                 if let Some(block) = e.block() {
-                    self.infer_block(block)
+                    self.infer_block(block)?
                 } else {
                     Ty::Unknown
                 }
             }
             ast::Expr::LoopExpr(e) => {
                 if let Some(block) = e.loop_body() {
-                    self.infer_block(block);
+                    self.infer_block(block)?;
                 };
                 // TODO never, or the type of the break param
                 Ty::Unknown
@@ -320,59 +364,69 @@ impl InferenceContext {
                 if let Some(condition) = e.condition() {
                     if let Some(e) = condition.expr() {
                         // TODO if no pat, this should be bool
-                        self.infer_expr(e);
+                        self.infer_expr(e)?;
                     }
                     // TODO write type for pat
                 };
                 if let Some(block) = e.loop_body() {
                     // TODO
-                    self.infer_block(block);
+                    self.infer_block(block)?;
                 };
                 // TODO always unit?
                 Ty::Unknown
             }
             ast::Expr::ForExpr(e) => {
                 if let Some(expr) = e.iterable() {
-                    self.infer_expr(expr);
+                    self.infer_expr(expr)?;
                 }
                 if let Some(_pat) = e.pat() {
                     // TODO write type for pat
                 }
                 if let Some(block) = e.loop_body() {
-                    self.infer_block(block);
+                    self.infer_block(block)?;
                 }
                 // TODO always unit?
                 Ty::Unknown
             }
             ast::Expr::LambdaExpr(e) => {
                 let _body_ty = if let Some(body) = e.body() {
-                    self.infer_expr(body)
+                    self.infer_expr(body)?
                 } else {
                     Ty::Unknown
                 };
                 Ty::Unknown
             }
             ast::Expr::CallExpr(e) => {
+                let _callee_ty = if let Some(e) = e.expr() {
+                    self.infer_expr(e)?
+                } else {
+                    Ty::Unknown
+                };
                 if let Some(arg_list) = e.arg_list() {
                     for arg in arg_list.args() {
                         // TODO unify / expect argument type
-                        self.infer_expr(arg);
+                        self.infer_expr(arg)?;
                     }
                 }
                 Ty::Unknown
             }
             ast::Expr::MethodCallExpr(e) => {
+                let _receiver_ty = if let Some(e) = e.expr() {
+                    self.infer_expr(e)?
+                } else {
+                    Ty::Unknown
+                };
                 if let Some(arg_list) = e.arg_list() {
                     for arg in arg_list.args() {
                         // TODO unify / expect argument type
-                        self.infer_expr(arg);
+                        self.infer_expr(arg)?;
                     }
                 }
                 Ty::Unknown
             }
             ast::Expr::MatchExpr(e) => {
                 let _ty = if let Some(match_expr) = e.expr() {
-                    self.infer_expr(match_expr)
+                    self.infer_expr(match_expr)?
                 } else {
                     Ty::Unknown
                 };
@@ -381,7 +435,7 @@ impl InferenceContext {
                         // TODO type the bindings in pat
                         // TODO type the guard
                         let _ty = if let Some(e) = arm.expr() {
-                            self.infer_expr(e)
+                            self.infer_expr(e)?
                         } else {
                             Ty::Unknown
                         };
@@ -394,12 +448,12 @@ impl InferenceContext {
             }
             ast::Expr::TupleExpr(_e) => Ty::Unknown,
             ast::Expr::ArrayExpr(_e) => Ty::Unknown,
-            ast::Expr::PathExpr(e) => self.infer_path_expr(e).unwrap_or(Ty::Unknown),
+            ast::Expr::PathExpr(e) => self.infer_path_expr(e)?.unwrap_or(Ty::Unknown),
             ast::Expr::ContinueExpr(_e) => Ty::Never,
             ast::Expr::BreakExpr(_e) => Ty::Never,
             ast::Expr::ParenExpr(e) => {
                 if let Some(e) = e.expr() {
-                    self.infer_expr(e)
+                    self.infer_expr(e)?
                 } else {
                     Ty::Unknown
                 }
@@ -408,7 +462,7 @@ impl InferenceContext {
             ast::Expr::ReturnExpr(e) => {
                 if let Some(e) = e.expr() {
                     // TODO unify with return type
-                    self.infer_expr(e);
+                    self.infer_expr(e)?;
                 };
                 Ty::Never
             }
@@ -425,7 +479,7 @@ impl InferenceContext {
             ast::Expr::FieldExpr(_e) => Ty::Unknown,
             ast::Expr::TryExpr(e) => {
                 let _inner_ty = if let Some(e) = e.expr() {
-                    self.infer_expr(e)
+                    self.infer_expr(e)?
                 } else {
                     Ty::Unknown
                 };
@@ -433,7 +487,7 @@ impl InferenceContext {
             }
             ast::Expr::CastExpr(e) => {
                 let _inner_ty = if let Some(e) = e.expr() {
-                    self.infer_expr(e)
+                    self.infer_expr(e)?
                 } else {
                     Ty::Unknown
                 };
@@ -443,7 +497,7 @@ impl InferenceContext {
             }
             ast::Expr::RefExpr(e) => {
                 let _inner_ty = if let Some(e) = e.expr() {
-                    self.infer_expr(e)
+                    self.infer_expr(e)?
                 } else {
                     Ty::Unknown
                 };
@@ -451,7 +505,7 @@ impl InferenceContext {
             }
             ast::Expr::PrefixExpr(e) => {
                 let _inner_ty = if let Some(e) = e.expr() {
-                    self.infer_expr(e)
+                    self.infer_expr(e)?
                 } else {
                     Ty::Unknown
                 };
@@ -462,10 +516,10 @@ impl InferenceContext {
             ast::Expr::Literal(_e) => Ty::Unknown,
         };
         self.write_ty(expr.syntax(), ty.clone());
-        ty
+        Ok(ty)
     }
 
-    fn infer_block(&mut self, node: ast::Block) -> Ty {
+    fn infer_block(&mut self, node: ast::Block) -> Cancelable<Ty> {
         for stmt in node.statements() {
             match stmt {
                 ast::Stmt::LetStmt(stmt) => {
@@ -476,7 +530,7 @@ impl InferenceContext {
                     };
                     let ty = if let Some(expr) = stmt.initializer() {
                         // TODO pass expectation
-                        let expr_ty = self.infer_expr(expr);
+                        let expr_ty = self.infer_expr(expr)?;
                         self.unify_with_coercion(&expr_ty, &decl_ty)
                             .unwrap_or(decl_ty)
                     } else {
@@ -489,23 +543,28 @@ impl InferenceContext {
                 }
                 ast::Stmt::ExprStmt(expr_stmt) => {
                     if let Some(expr) = expr_stmt.expr() {
-                        self.infer_expr(expr);
+                        self.infer_expr(expr)?;
                     }
                 }
             }
         }
         let ty = if let Some(expr) = node.expr() {
-            self.infer_expr(expr)
+            self.infer_expr(expr)?
         } else {
             Ty::unit()
         };
         self.write_ty(node.syntax(), ty.clone());
-        ty
+        Ok(ty)
     }
 }
 
-pub fn infer(_db: &impl HirDatabase, node: ast::FnDef, scopes: Arc<FnScopes>) -> InferenceResult {
-    let mut ctx = InferenceContext::new(scopes);
+pub fn infer(db: &impl HirDatabase, function: Function) -> Cancelable<InferenceResult> {
+    let scopes = function.scopes(db);
+    let module = function.module(db)?;
+    let mut ctx = InferenceContext::new(db, scopes, module);
+
+    let syntax = function.syntax(db);
+    let node = syntax.borrowed();
 
     if let Some(param_list) = node.param_list() {
         for param in param_list.params() {
@@ -529,12 +588,12 @@ pub fn infer(_db: &impl HirDatabase, node: ast::FnDef, scopes: Arc<FnScopes>) ->
     // (see Expectation in rustc_typeck)
 
     if let Some(block) = node.body() {
-        ctx.infer_block(block);
+        ctx.infer_block(block)?;
     }
 
     // TODO 'resolve' the types: replace inference variables by their inferred results
 
-    InferenceResult {
+    Ok(InferenceResult {
         type_for: ctx.type_for,
-    }
+    })
 }