Merge #327

327: Beginnings of type inference r=flodiebold a=flodiebold

I was a bit bored, so I thought I'd try to start implementing the type system and see how far I come 😉  This is obviously still extremely WIP, only very basic stuff working, but I thought I'd post this now to get some feedback as to whether this approach makes sense at all.

There's no user-visible effect yet, but the type inference has tests similar to the ones for the parser. My next step will probably be to implement struct types, after which this could probably be used to complete fields.

I realize this may all get thrown away when/if the compiler query system gets usable, but I feel like there are lots of IDE features that could be implemented with somewhat working type inference in the meantime 😄 

Co-authored-by: Florian Diebold <flodiebold@gmail.com>

Author: bors[bot]

Cargo.lock

@@ -93,6 +93,8 @@ salsa::database_storage! {
             fn item_map() for hir::db::ItemMapQuery;
             fn fn_syntax() for hir::db::FnSyntaxQuery;
             fn submodules() for hir::db::SubmodulesQuery;
+            fn infer() for hir::db::InferQuery;
+            fn type_for_def() for hir::db::TypeForDefQuery;
         }
     }
 }

crates/ra_analysis/src/db.rs

@@ -5,7 +5,8 @@ use std::{
 
 use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit};
 use ra_syntax::{
-    ast::{self, ArgListOwner, Expr, NameOwner},
+    ast::{self, ArgListOwner, Expr, NameOwner, FnDef},
+    algo::find_covering_node,
     AstNode, SourceFileNode,
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
@@ -510,6 +511,23 @@ impl AnalysisImpl {
         Ok(None)
     }
 
+    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
+        let file = self.db.source_file(file_id);
+        let syntax = file.syntax();
+        let node = find_covering_node(syntax, range);
+        let parent_fn = node.ancestors().filter_map(FnDef::cast).next();
+        let parent_fn = if let Some(p) = parent_fn {
+            p
+        } else {
+            return Ok(None);
+        };
+        let function = ctry!(source_binder::function_from_source(
+            &*self.db, file_id, parent_fn
+        )?);
+        let infer = function.infer(&*self.db)?;
+        Ok(infer.type_of_node(node).map(|t| t.to_string()))
+    }
+
     fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());

crates/ra_analysis/src/imp.rs

@@ -366,6 +366,9 @@ impl Analysis {
     ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
         self.imp.resolve_callable(position)
     }
+    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
+        self.imp.type_of(file_id, range)
+    }
 }
 
 pub struct LibraryData {

crates/ra_analysis/src/lib.rs

@@ -16,3 +16,6 @@ ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
 ra_db = { path = "../ra_db" }
 test_utils = { path = "../test_utils" }
+
+[dev-dependencies]
+flexi_logger = "0.10.0"

crates/ra_hir/Cargo.toml

@@ -14,6 +14,7 @@ use crate::{
     function::FnId,
     module::{ModuleId, ModuleTree, ModuleSource,
     nameres::{ItemMap, InputModuleItems}},
+    ty::{InferenceResult, Ty},
 };
 
 salsa::query_group! {
@@ -30,6 +31,16 @@ pub trait HirDatabase: SyntaxDatabase
         use fn query_definitions::fn_syntax;
     }
 
+    fn infer(fn_id: FnId) -> Cancelable<Arc<InferenceResult>> {
+        type InferQuery;
+        use fn query_definitions::infer;
+    }
+
+    fn type_for_def(def_id: DefId) -> Cancelable<Ty> {
+        type TypeForDefQuery;
+        use fn query_definitions::type_for_def;
+    }
+
     fn file_items(file_id: FileId) -> Arc<SourceFileItems> {
         type SourceFileItemsQuery;
         use fn query_definitions::file_items;

crates/ra_hir/src/db.rs

@@ -5,20 +5,21 @@ use std::{
     sync::Arc,
 };
 
+use ra_db::Cancelable;
 use ra_syntax::{
     TextRange, TextUnit,
     ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
 
-use crate::{ DefId, HirDatabase };
+use crate::{ DefId, HirDatabase, ty::InferenceResult, Module };
 
 pub use self::scope::FnScopes;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct FnId(pub(crate) DefId);
 
 pub struct Function {
-    fn_id: FnId,
+    pub(crate) fn_id: FnId,
 }
 
 impl Function {
@@ -27,6 +28,10 @@ impl Function {
         Function { fn_id }
     }
 
+    pub fn syntax(&self, db: &impl HirDatabase) -> ast::FnDefNode {
+        db.fn_syntax(self.fn_id)
+    }
+
     pub fn scopes(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
         db.fn_scopes(self.fn_id)
     }
@@ -35,6 +40,15 @@ impl Function {
         let syntax = db.fn_syntax(self.fn_id);
         FnSignatureInfo::new(syntax.borrowed())
     }
+
+    pub fn infer(&self, db: &impl HirDatabase) -> Cancelable<Arc<InferenceResult>> {
+        db.infer(self.fn_id)
+    }
+
+    pub fn module(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+        let loc = self.fn_id.0.loc(db);
+        Module::new(db, loc.source_root_id, loc.module_id)
+    }
 }
 
 #[derive(Debug, Clone)]

crates/ra_hir/src/function.rs

@@ -25,10 +25,11 @@ pub mod source_binder;
 mod krate;
 mod module;
 mod function;
+mod ty;
 
 use std::ops::Index;
 
-use ra_syntax::{SyntaxNodeRef, SyntaxNode};
+use ra_syntax::{SyntaxNodeRef, SyntaxNode, SyntaxKind};
 use ra_db::{LocationIntener, SourceRootId, FileId, Cancelable};
 
 use crate::{
@@ -66,6 +67,23 @@ pub struct DefLoc {
     source_item_id: SourceItemId,
 }
 
+impl DefKind {
+    pub(crate) fn for_syntax_kind(kind: SyntaxKind) -> Option<DefKind> {
+        match kind {
+            SyntaxKind::FN_DEF => Some(DefKind::Function),
+            SyntaxKind::MODULE => Some(DefKind::Module),
+            // These define items, but don't have their own DefKinds yet:
+            SyntaxKind::STRUCT_DEF => Some(DefKind::Item),
+            SyntaxKind::ENUM_DEF => Some(DefKind::Item),
+            SyntaxKind::TRAIT_DEF => Some(DefKind::Item),
+            SyntaxKind::TYPE_DEF => Some(DefKind::Item),
+            SyntaxKind::CONST_DEF => Some(DefKind::Item),
+            SyntaxKind::STATIC_DEF => Some(DefKind::Item),
+            _ => None,
+        }
+    }
+}
+
 impl DefId {
     pub(crate) fn loc(self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefLoc {
         db.as_ref().id2loc(self)

crates/ra_hir/src/lib.rs

@@ -8,7 +8,7 @@ use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
 
 use crate::{db, DefId, DefLoc};
 
-const WORKSPACE: SourceRootId = SourceRootId(0);
+pub const WORKSPACE: SourceRootId = SourceRootId(0);
 
 #[derive(Debug)]
 pub(crate) struct MockDatabase {
@@ -24,6 +24,15 @@ impl MockDatabase {
         (db, source_root)
     }
 
+    pub(crate) fn with_single_file(text: &str) -> (MockDatabase, SourceRoot, FileId) {
+        let mut db = MockDatabase::default();
+        let mut source_root = SourceRoot::default();
+        let file_id = db.add_file(&mut source_root, "/main.rs", text);
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(WORKSPACE, Arc::new(source_root.clone()));
+        (db, source_root, file_id)
+    }
+
     pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
         let (db, _, position) = MockDatabase::from_fixture(fixture);
         let position = position.expect("expected a marker ( <|> )");
@@ -182,6 +191,8 @@ salsa::database_storage! {
             fn item_map() for db::ItemMapQuery;
             fn fn_syntax() for db::FnSyntaxQuery;
             fn submodules() for db::SubmodulesQuery;
+            fn infer() for db::InferQuery;
+            fn type_for_def() for db::TypeForDefQuery;
         }
     }
 }

crates/ra_hir/src/mock.rs

@@ -2,6 +2,7 @@ pub(super) mod imp;
 pub(super) mod nameres;
 
 use std::sync::Arc;
+use log;
 
 use ra_syntax::{
     algo::generate,