73 files changed, 869 insertions, 1131 deletions

diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index a82e1761c..17b04182f 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "ra_analysis"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
@@ -14,7 +15,7 @@ fst = "0.3.1"
 im = "12.0.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
-salsa = { path = "../salsa" }
+salsa = "0.5.0"
 rustc-hash = "1.0"
 
 [dev-dependencies]
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
new file mode 100644
index 000000000..c69577233
--- /dev/null
+++ b/crates/ra_analysis/src/db.rs
@@ -0,0 +1,117 @@
+use std::{
+    fmt,
+    sync::Arc,
+    hash::{Hash, Hasher},
+};
+use salsa;
+use rustc_hash::FxHashSet;
+use ra_syntax::File;
+use ra_editor::{LineIndex};
+use crate::{
+    symbol_index::SymbolIndex,
+    module_map::{ModulesDatabase, ModuleTreeQuery, ModuleDescriptorQuery},
+    FileId, FileResolverImp,
+};
+
+#[derive(Default)]
+pub(crate) struct RootDatabase {
+    runtime: salsa::runtime::Runtime<RootDatabase>,
+}
+
+impl fmt::Debug for RootDatabase {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str("RootDatabase { ... }")
+    }
+}
+
+impl salsa::Database for RootDatabase {
+    fn salsa_runtime(&self) -> &salsa::runtime::Runtime<RootDatabase> {
+        &self.runtime
+    }
+}
+
+impl salsa::ParallelDatabase for RootDatabase {
+    fn fork(&self) -> Self {
+        RootDatabase {
+            runtime: self.runtime.fork(),
+        }
+    }
+}
+
+impl Clone for RootDatabase {
+    fn clone(&self) -> RootDatabase {
+        salsa::ParallelDatabase::fork(self)
+    }
+}
+
+salsa::database_storage! {
+    pub(crate) struct RootDatabaseStorage for RootDatabase {
+        impl FilesDatabase {
+            fn file_text() for FileTextQuery;
+            fn file_set() for FileSetQuery;
+        }
+        impl SyntaxDatabase {
+            fn file_syntax() for FileSyntaxQuery;
+            fn file_lines() for FileLinesQuery;
+            fn file_symbols() for FileSymbolsQuery;
+        }
+        impl ModulesDatabase {
+            fn module_tree() for ModuleTreeQuery;
+            fn module_descriptor() for ModuleDescriptorQuery;
+        }
+    }
+}
+
+salsa::query_group! {
+    pub(crate) trait FilesDatabase: salsa::Database {
+        fn file_text(file_id: FileId) -> Arc<String> {
+            type FileTextQuery;
+            storage input;
+        }
+        fn file_set(key: ()) -> Arc<FileSet> {
+            type FileSetQuery;
+            storage input;
+        }
+    }
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub(crate) struct FileSet {
+    pub(crate) files: FxHashSet<FileId>,
+    pub(crate) resolver: FileResolverImp,
+}
+
+impl Hash for FileSet {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        let mut files = self.files.iter().cloned().collect::<Vec<_>>();
+        files.sort();
+        files.hash(hasher);
+    }
+}
+
+salsa::query_group! {
+    pub(crate) trait SyntaxDatabase: FilesDatabase {
+        fn file_syntax(file_id: FileId) -> File {
+            type FileSyntaxQuery;
+        }
+        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
+            type FileLinesQuery;
+        }
+        fn file_symbols(file_id: FileId) -> Arc<SymbolIndex> {
+            type FileSymbolsQuery;
+        }
+    }
+}
+
+fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> File {
+    let text = db.file_text(file_id);
+    File::parse(&*text)
+}
+fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
+    let text = db.file_text(file_id);
+    Arc::new(LineIndex::new(&*text))
+}
+fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<SymbolIndex> {
+    let syntax = db.file_syntax(file_id);
+    Arc::new(SymbolIndex::for_file(file_id, syntax))
+}
diff --git a/crates/ra_analysis/src/db/imp.rs b/crates/ra_analysis/src/db/imp.rs
deleted file mode 100644
index 36f6cf290..000000000
--- a/crates/ra_analysis/src/db/imp.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use std::{
-    sync::Arc,
-    any::Any,
-    hash::{Hash, Hasher},
-    collections::hash_map::{DefaultHasher},
-    iter,
-};
-use rustc_hash::FxHashMap;
-use salsa;
-use {FileId, imp::FileResolverImp};
-use super::{State, Query, QueryCtx};
-
-pub(super) type Data = Arc<Any + Send + Sync + 'static>;
-
-#[derive(Debug)]
-pub(super) struct Db {
-    names: Arc<FxHashMap<salsa::QueryTypeId, &'static str>>,
-    pub(super) imp: salsa::Db<State, Data>,
-}
-
-impl Db {
-    pub(super) fn new(mut reg: QueryRegistry) -> Db {
-        let config = reg.config.take().unwrap();
-        Db {
-            names: Arc::new(reg.names),
-            imp: salsa::Db::new(config, State::default())
-        }
-    }
-    pub(crate) fn with_changes(&self, new_state: State, changed_files: &[FileId], resolver_changed: bool) -> Db {
-        let names = self.names.clone();
-        let mut invalidations = salsa::Invalidations::new();
-        invalidations.invalidate(FILE_TEXT, changed_files.iter().map(hash).map(salsa::InputFingerprint));
-        if resolver_changed {
-            invalidations.invalidate(FILE_SET, iter::once(salsa::InputFingerprint(hash(&()))));
-        } else {
-            invalidations.invalidate(FILE_SET, iter::empty());
-        }
-        let imp = self.imp.with_ground_data(
-            new_state,
-            invalidations,
-        );
-        Db { names, imp }
-    }
-    pub(super) fn extract_trace(&self, ctx: &salsa::QueryCtx<State, Data>) -> Vec<&'static str> {
-        ctx.trace().into_iter().map(|it| self.names[&it]).collect()
-    }
-}
-
-pub(crate) trait EvalQuery {
-    type Params;
-    type Output;
-    fn query_type(&self) -> salsa::QueryTypeId;
-    fn f(&self) -> salsa::QueryFn<State, Data>;
-    fn get(&self, &QueryCtx, Self::Params) -> Arc<Self::Output>;
-}
-
-impl<T, R> EvalQuery for Query<T, R>
-where
-    T: Hash + Send + Sync + 'static,
-    R: Hash + Send + Sync + 'static,
-{
-    type Params = T;
-    type Output = R;
-    fn query_type(&self) -> salsa::QueryTypeId {
-        salsa::QueryTypeId(self.0)
-    }
-    fn f(&self) -> salsa::QueryFn<State, Data> {
-        let f = self.1;
-        Box::new(move |ctx, data| {
-            let ctx = QueryCtx { imp: ctx };
-            let data: &T = data.downcast_ref().unwrap();
-            let res = f(ctx, data);
-            let h = hash(&res);
-            (Arc::new(res), salsa::OutputFingerprint(h))
-        })
-    }
-    fn get(&self, ctx: &QueryCtx, params: Self::Params) -> Arc<Self::Output> {
-        let query_id = salsa::QueryId(
-            self.query_type(),
-            salsa::InputFingerprint(hash(&params)),
-        );
-        let res = ctx.imp.get(query_id, Arc::new(params));
-        res.downcast().unwrap()
-    }
-}
-
-pub(super) struct QueryRegistry {
-    config: Option<salsa::QueryConfig<State, Data>>,
-    names: FxHashMap<salsa::QueryTypeId, &'static str>,
-}
-
-impl QueryRegistry {
-    pub(super) fn new() -> QueryRegistry {
-        let mut config = salsa::QueryConfig::<State, Data>::new();
-        config = config.with_ground_query(
-            FILE_TEXT, Box::new(|state, params| {
-                let file_id: &FileId = params.downcast_ref().unwrap();
-                let res = state.file_map[file_id].clone();
-                let fingerprint = salsa::OutputFingerprint(hash(&res));
-                (res, fingerprint)
-            })
-        );
-        config = config.with_ground_query(
-            FILE_SET, Box::new(|state, _params| {
-                let file_ids: Vec<FileId> = state.file_map.keys().cloned().collect();
-                let hash = hash(&file_ids);
-                let file_resolver = state.file_resolver.clone();
-                let res = (file_ids, file_resolver);
-                let fingerprint = salsa::OutputFingerprint(hash);
-                (Arc::new(res), fingerprint)
-            })
-        );
-        let mut names = FxHashMap::default();
-        names.insert(FILE_TEXT, "FILE_TEXT");
-        names.insert(FILE_SET, "FILE_SET");
-        QueryRegistry { config: Some(config), names }
-    }
-    pub(super) fn add<Q: EvalQuery>(&mut self, q: Q, name: &'static str) {
-        let id = q.query_type();
-        let prev = self.names.insert(id, name);
-        assert!(prev.is_none(), "duplicate query: {:?}", id);
-        let config = self.config.take().unwrap();
-        let config = config.with_query(id, q.f());
-        self.config= Some(config);
-    }
-}
-
-fn hash<T: Hash>(x: &T) -> u64 {
-    let mut hasher = DefaultHasher::new();
-    x.hash(&mut hasher);
-    hasher.finish()
-}
-
-const FILE_TEXT: salsa::QueryTypeId = salsa::QueryTypeId(0);
-pub(super) fn file_text(ctx: QueryCtx, file_id: FileId) -> Arc<String> {
-    let query_id = salsa::QueryId(
-        FILE_TEXT,
-        salsa::InputFingerprint(hash(&file_id)),
-    );
-    let res = ctx.imp.get(query_id, Arc::new(file_id));
-    res.downcast().unwrap()
-}
-
-const FILE_SET: salsa::QueryTypeId = salsa::QueryTypeId(1);
-pub(super) fn file_set(ctx: QueryCtx) -> Arc<(Vec<FileId>, FileResolverImp)> {
-    let query_id = salsa::QueryId(
-        FILE_SET,
-        salsa::InputFingerprint(hash(&())),
-    );
-    let res = ctx.imp.get(query_id, Arc::new(()));
-    res.downcast().unwrap()
-}
-
diff --git a/crates/ra_analysis/src/db/mod.rs b/crates/ra_analysis/src/db/mod.rs
deleted file mode 100644
index 22769d112..000000000
--- a/crates/ra_analysis/src/db/mod.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-mod imp;
-
-use std::{
-    sync::Arc,
-};
-use im;
-use salsa;
-use {FileId, imp::FileResolverImp};
-
-#[derive(Debug, Default, Clone)]
-pub(crate) struct State {
-    pub(crate) file_map: im::HashMap<FileId, Arc<String>>,
-    pub(crate) file_resolver: FileResolverImp
-}
-
-#[derive(Debug)]
-pub(crate) struct Db {
-    imp: imp::Db,
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct QueryCtx<'a> {
-    imp: &'a salsa::QueryCtx<State, imp::Data>,
-}
-
-pub(crate) struct Query<T, R>(pub(crate) u16, pub(crate) fn(QueryCtx, &T) -> R);
-
-pub(crate) struct QueryRegistry {
-    imp: imp::QueryRegistry,
-}
-
-impl Default for Db {
-    fn default() -> Db {
-        Db::new()
-    }
-}
-
-impl Db {
-    pub(crate) fn new() -> Db {
-        let reg = QueryRegistry::new();
-        Db { imp: imp::Db::new(reg.imp) }
-    }
-    pub(crate) fn state(&self) -> &State {
-        self.imp.imp.ground_data()
-    }
-    pub(crate) fn with_changes(&self, new_state: State, changed_files: &[FileId], resolver_changed: bool) -> Db {
-        Db { imp: self.imp.with_changes(new_state, changed_files, resolver_changed) }
-    }
-    pub(crate) fn make_query<F: FnOnce(QueryCtx) -> R, R>(&self, f: F) -> R {
-        let ctx = QueryCtx { imp: &self.imp.imp.query_ctx() };
-        f(ctx)
-    }
-    #[allow(unused)]
-    pub(crate) fn trace_query<F: FnOnce(QueryCtx) -> R, R>(&self, f: F) -> (R, Vec<&'static str>) {
-        let ctx = QueryCtx { imp: &self.imp.imp.query_ctx() };
-        let res = f(ctx);
-        let trace = self.imp.extract_trace(ctx.imp);
-        (res, trace)
-    }
-}
-
-impl<'a> QueryCtx<'a> {
-    pub(crate) fn get<Q: imp::EvalQuery>(&self, q: Q, params: Q::Params) -> Arc<Q::Output> {
-        q.get(self, params)
-    }
-}
-
-pub(crate) fn file_text(ctx: QueryCtx, file_id: FileId) -> Arc<String> {
-    imp::file_text(ctx, file_id)
-}
-
-pub(crate) fn file_set(ctx: QueryCtx) -> Arc<(Vec<FileId>, FileResolverImp)> {
-    imp::file_set(ctx)
-}
-impl QueryRegistry {
-    fn new() -> QueryRegistry {
-        let mut reg = QueryRegistry { imp: imp::QueryRegistry::new() };
-        ::queries::register_queries(&mut reg);
-        ::module_map::register_queries(&mut reg);
-        reg
-    }
-    pub(crate) fn add<Q: imp::EvalQuery>(&mut self, q: Q, name: &'static str) {
-        self.imp.add(q, name)
-    }
-}
diff --git a/crates/ra_analysis/src/descriptors.rs b/crates/ra_analysis/src/descriptors.rs
index 0731b5572..8d9f38ca5 100644
--- a/crates/ra_analysis/src/descriptors.rs
+++ b/crates/ra_analysis/src/descriptors.rs
@@ -4,14 +4,15 @@ use std::{
 use relative_path::RelativePathBuf;
 use ra_syntax::{
     SmolStr,
-    ast::{self, NameOwner},
+    ast::{self, NameOwner, AstNode},
+    text_utils::is_subrange
 };
-use {
+use crate::{
     FileId,
     imp::FileResolverImp,
 };
 
-#[derive(Debug, Hash)]
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub struct ModuleDescriptor {
     pub submodules: Vec<Submodule>
 }
@@ -42,7 +43,7 @@ pub struct Submodule {
     pub name: SmolStr,
 }
 
-#[derive(Hash, Debug)]
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub(crate) struct ModuleTreeDescriptor {
     nodes: Vec<NodeData>,
     links: Vec<LinkData>,
@@ -51,7 +52,7 @@ pub(crate) struct ModuleTreeDescriptor {
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 struct Node(usize);
-#[derive(Hash, Debug)]
+#[derive(Hash, Debug, PartialEq, Eq)]
 struct NodeData {
     file_id: FileId,
     links: Vec<Link>,
@@ -60,7 +61,7 @@ struct NodeData {
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct Link(usize);
-#[derive(Hash, Debug)]
+#[derive(Hash, Debug, PartialEq, Eq)]
 struct LinkData {
     owner: Node,
     name: SmolStr,
@@ -69,7 +70,7 @@ struct LinkData {
 }
 
 
-#[derive(Clone, Debug, Hash)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum Problem {
     UnresolvedModule {
         candidate: RelativePathBuf,
@@ -218,3 +219,56 @@ fn resolve_submodule(
     }
     (points_to, problem)
 }
+
+#[derive(Debug, Clone)]
+pub struct FnDescriptor {
+    pub name: String,
+    pub label : String,
+    pub ret_type: Option<String>,
+    pub params: Vec<String>,
+}
+
+impl FnDescriptor {
+    pub fn new(node: ast::FnDef) -> Option<Self> {
+        let name = node.name()?.text().to_string();
+
+        // Strip the body out for the label.
+        let label : String = if let Some(body) = node.body() {
+            let body_range = body.syntax().range();
+            let label : String = node.syntax().children()
+                .filter(|child| !is_subrange(body_range, child.range()))
+                .map(|node| node.text().to_string())
+                .collect();
+            label
+        } else {
+            node.syntax().text().to_string()
+        };
+
+        let params = FnDescriptor::param_list(node);
+        let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
+
+        Some(FnDescriptor {
+            name,
+            ret_type,
+            params,
+            label
+        })
+    }
+
+    fn param_list(node: ast::FnDef) -> Vec<String> {
+        let mut res = vec![];
+        if let Some(param_list) = node.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                res.push(self_param.syntax().text().to_string())
+            }
+
+            // Maybe use param.pat here? See if we can just extract the name?
+            //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
+            res.extend(param_list.params()
+                .filter_map(|p| p.pat())
+                .map(|pat| pat.syntax().text().to_string())
+            );
+        }
+        res
+    }
+}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 47bc0032b..5efcaeca0 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,8 +1,8 @@
 use std::{
     sync::{
         Arc,
-        atomic::{AtomicBool, Ordering::SeqCst},
     },
+    hash::{Hash, Hasher},
     fmt,
     collections::VecDeque,
     iter,
@@ -12,24 +12,38 @@ use relative_path::RelativePath;
 use rustc_hash::FxHashSet;
 use ra_editor::{self, FileSymbol, LineIndex, find_node_at_offset, LocalEdit, resolve_local_name};
 use ra_syntax::{
-    TextUnit, TextRange, SmolStr, File, AstNode,
+    TextUnit, TextRange, SmolStr, File, AstNode, SyntaxNodeRef,
     SyntaxKind::*,
-    ast::{self, NameOwner},
+    ast::{self, NameOwner, ArgListOwner, Expr},
 };
 
-use {
+use crate::{
     FileId, FileResolver, Query, Diagnostic, SourceChange, SourceFileEdit, Position, FileSystemEdit,
     JobToken, CrateGraph, CrateId,
     roots::{SourceRoot, ReadonlySourceRoot, WritableSourceRoot},
-    descriptors::{ModuleTreeDescriptor, Problem},
+    descriptors::{FnDescriptor, ModuleTreeDescriptor, Problem},
 };
 
-
 #[derive(Clone, Debug)]
 pub(crate) struct FileResolverImp {
     inner: Arc<FileResolver>
 }
 
+impl PartialEq for FileResolverImp {
+    fn eq(&self, other: &FileResolverImp) -> bool {
+        self.inner() == other.inner()
+    }
+}
+
+impl Eq for FileResolverImp {
+}
+
+impl Hash for FileResolverImp {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.inner().hash(hasher);
+    }
+}
+
 impl FileResolverImp {
     pub(crate) fn new(inner: Arc<FileResolver>) -> FileResolverImp {
         FileResolverImp { inner }
@@ -40,6 +54,9 @@ impl FileResolverImp {
     pub(crate) fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
         self.inner.resolve(file_id, path)
     }
+    fn inner(&self) -> *const FileResolver {
+        &*self.inner
+    }
 }
 
 impl Default for FileResolverImp {
@@ -60,29 +77,27 @@ impl Default for FileResolverImp {
 
 #[derive(Debug)]
 pub(crate) struct AnalysisHostImpl {
-    data: Arc<WorldData>
+    data: WorldData
 }
 
 impl AnalysisHostImpl {
     pub fn new() -> AnalysisHostImpl {
         AnalysisHostImpl {
-            data: Arc::new(WorldData::default()),
+            data: WorldData::default(),
         }
     }
     pub fn analysis(&self) -> AnalysisImpl {
         AnalysisImpl {
-            needs_reindex: AtomicBool::new(false),
             data: self.data.clone(),
         }
     }
     pub fn change_files(&mut self, changes: &mut dyn Iterator<Item=(FileId, Option<String>)>) {
-        let data = self.data_mut();
-        data.root = Arc::new(data.root.apply_changes(changes, None));
+        self.data_mut()
+            .root.apply_changes(changes, None);
     }
     pub fn set_file_resolver(&mut self, resolver: FileResolverImp) {
-        let data = self.data_mut();
-        data.file_resolver = resolver.clone();
-        data.root = Arc::new(data.root.apply_changes(&mut iter::empty(), Some(resolver)));
+        self.data_mut()
+            .root.apply_changes(&mut iter::empty(), Some(resolver));
     }
     pub fn set_crate_graph(&mut self, graph: CrateGraph) {
         let mut visited = FxHashSet::default();
@@ -97,34 +112,24 @@ impl AnalysisHostImpl {
         self.data_mut().libs.push(Arc::new(root));
     }
     fn data_mut(&mut self) -> &mut WorldData {
-        Arc::make_mut(&mut self.data)
+        &mut self.data
     }
 }
 
 pub(crate) struct AnalysisImpl {
-    needs_reindex: AtomicBool,
-    data: Arc<WorldData>,
+    data: WorldData,
 }
 
 impl fmt::Debug for AnalysisImpl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        (&*self.data).fmt(f)
-    }
-}
-
-impl Clone for AnalysisImpl {
-    fn clone(&self) -> AnalysisImpl {
-        AnalysisImpl {
-            needs_reindex: AtomicBool::new(self.needs_reindex.load(SeqCst)),
-            data: Arc::clone(&self.data),
-        }
+        self.data.fmt(f)
     }
 }
 
 impl AnalysisImpl {
     fn root(&self, file_id: FileId) -> &SourceRoot {
         if self.data.root.contains(file_id) {
-            return &*self.data.root;
+            return &self.data.root;
         }
         &**self.data.libs.iter().find(|it| it.contains(file_id)).unwrap()
     }
@@ -306,6 +311,68 @@ impl AnalysisImpl {
             .collect()
     }
 
+    pub fn resolve_callable(&self, file_id: FileId, offset: TextUnit, token: &JobToken)
+        -> Option<(FnDescriptor, Option<usize>)> {
+
+        let root = self.root(file_id);
+        let file = root.syntax(file_id);
+        let syntax = file.syntax();
+
+        // Find the calling expression and it's NameRef
+        let calling_node = FnCallNode::with_node(syntax, offset)?;
+        let name_ref = calling_node.name_ref()?;
+
+        // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
+        let file_symbols = self.index_resolve(name_ref, token);
+        for (_, fs) in file_symbols {
+            if fs.kind == FN_DEF {
+                if let Some(fn_def) = find_node_at_offset(syntax, fs.node_range.start()) {
+                    if let Some(descriptor) = FnDescriptor::new(fn_def) {
+                        // If we have a calling expression let's find which argument we are on
+                        let mut current_parameter = None;
+
+                        let num_params = descriptor.params.len();
+                        let has_self = fn_def.param_list()
+                            .and_then(|l| l.self_param())
+                            .is_some();
+
+                        if num_params == 1 {
+                            if !has_self {
+                                current_parameter = Some(1);
+                            }
+                        } else if num_params > 1 {
+                            // Count how many parameters into the call we are.
+                            // TODO: This is best effort for now and should be fixed at some point.
+                            // It may be better to see where we are in the arg_list and then check
+                            // where offset is in that list (or beyond).
+                            // Revisit this after we get documentation comments in.
+                            if let Some(ref arg_list) = calling_node.arg_list() {
+                                let start = arg_list.syntax().range().start();
+
+                                let range_search = TextRange::from_to(start, offset);
+                                let mut commas: usize = arg_list.syntax().text()
+                                    .slice(range_search).to_string()
+                                    .matches(",")
+                                    .count();
+
+                                // If we have a method call eat the first param since it's just self.
+                                if has_self {
+                                    commas = commas + 1;
+                                }
+
+                                current_parameter = Some(commas);
+                            }
+                        }
+
+                        return Some((descriptor, current_parameter));
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
     fn index_resolve(&self, name_ref: ast::NameRef, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
@@ -325,9 +392,8 @@ impl AnalysisImpl {
 
 #[derive(Default, Clone, Debug)]
 struct WorldData {
-    file_resolver: FileResolverImp,
     crate_graph: CrateGraph,
-    root: Arc<WritableSourceRoot>,
+    root: WritableSourceRoot,
     libs: Vec<Arc<ReadonlySourceRoot>>,
 }
 
@@ -355,3 +421,46 @@ impl CrateGraph {
         Some(crate_id)
     }
 }
+
+enum FnCallNode<'a> {
+    CallExpr(ast::CallExpr<'a>),
+    MethodCallExpr(ast::MethodCallExpr<'a>)
+}
+
+impl<'a> FnCallNode<'a> {
+    pub fn with_node(syntax: SyntaxNodeRef, offset: TextUnit) -> Option<FnCallNode> {
+        if let Some(expr) = find_node_at_offset::<ast::CallExpr>(syntax, offset) {
+            return Some(FnCallNode::CallExpr(expr));
+        }
+        if let Some(expr) = find_node_at_offset::<ast::MethodCallExpr>(syntax, offset) {
+            return Some(FnCallNode::MethodCallExpr(expr));
+        }
+        None
+    }
+
+    pub fn name_ref(&self) -> Option<ast::NameRef> {
+        match *self {
+            FnCallNode::CallExpr(call_expr) => {
+                Some(match call_expr.expr()? {
+                    Expr::PathExpr(path_expr) => {
+                        path_expr.path()?.segment()?.name_ref()?
+                    },
+                    _ => return None
+                })
+            },
+
+            FnCallNode::MethodCallExpr(call_expr) => {
+                call_expr.syntax().children()
+                    .filter_map(ast::NameRef::cast)
+                    .nth(0)
+            }
+        }
+    }
+
+    pub fn arg_list(&self) -> Option<ast::ArgList> {
+        match *self {
+            FnCallNode::CallExpr(expr) => expr.arg_list(),
+            FnCallNode::MethodCallExpr(expr) => expr.arg_list()
+        }
+    }
+}
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 849fd93e4..d8b355a81 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -19,7 +19,6 @@ mod imp;
 mod job;
 mod roots;
 mod db;
-mod queries;
 mod descriptors;
 
 use std::{
@@ -29,15 +28,18 @@ use std::{
 
 use relative_path::{RelativePath, RelativePathBuf};
 use ra_syntax::{File, TextRange, TextUnit, AtomEdit};
-use imp::{AnalysisImpl, AnalysisHostImpl, FileResolverImp};
 use rustc_hash::FxHashMap;
+use crate::imp::{AnalysisImpl, AnalysisHostImpl, FileResolverImp};
 
 pub use ra_editor::{
     StructureNode, LineIndex, FileSymbol,
     Runnable, RunnableKind, HighlightedRange, CompletionItem,
     Fold, FoldKind
 };
-pub use job::{JobToken, JobHandle};
+pub use crate::{
+    job::{JobToken, JobHandle},
+    descriptors::FnDescriptor,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FileId(pub u32);
@@ -159,7 +161,7 @@ impl Query {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Analysis {
     imp: AnalysisImpl
 }
@@ -236,6 +238,11 @@ impl Analysis {
         let file = self.imp.file_syntax(file_id);
         ra_editor::folding_ranges(&file)
     }
+
+    pub fn resolve_callable(&self, file_id: FileId, offset: TextUnit, token: &JobToken)
+        -> Option<(FnDescriptor, Option<usize>)> {
+        self.imp.resolve_callable(file_id, offset, token)
+    }
 }
 
 #[derive(Debug)]
@@ -250,3 +257,9 @@ impl LibraryData {
         LibraryData { root }
     }
 }
+
+#[test]
+fn analysis_is_send() {
+    fn is_send<T: Send>() {}
+    is_send::<Analysis>();
+}
diff --git a/crates/ra_analysis/src/module_map.rs b/crates/ra_analysis/src/module_map.rs
index a21f55fff..c1799e3d4 100644
--- a/crates/ra_analysis/src/module_map.rs
+++ b/crates/ra_analysis/src/module_map.rs
@@ -1,157 +1,34 @@
 use std::sync::Arc;
-use {
+use crate::{
     FileId,
-    db::{
-        Query, QueryRegistry, QueryCtx,
-        file_set
-    },
-    queries::file_syntax,
+    db::{SyntaxDatabase},
     descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
 };
 
-pub(crate) fn register_queries(reg: &mut QueryRegistry) {
-    reg.add(MODULE_DESCR, "MODULE_DESCR");
-    reg.add(MODULE_TREE, "MODULE_TREE");
-}
-
-pub(crate) fn module_tree(ctx: QueryCtx) -> Arc<ModuleTreeDescriptor> {
-    ctx.get(MODULE_TREE, ())
-}
-
-const MODULE_DESCR: Query<FileId, ModuleDescriptor> = Query(30, |ctx, &file_id| {
-    let file = file_syntax(ctx, file_id);
-    ModuleDescriptor::new(file.ast())
-});
-
-const MODULE_TREE: Query<(), ModuleTreeDescriptor> = Query(31, |ctx, _| {
-    let file_set = file_set(ctx);
-    let mut files = Vec::new();
-    for &file_id in file_set.0.iter() {
-        let module_descr = ctx.get(MODULE_DESCR, file_id);
-        files.push((file_id, module_descr));
-    }
-    ModuleTreeDescriptor::new(files.iter().map(|(file_id, descr)| (*file_id, &**descr)), &file_set.1)
-});
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-    use im;
-    use relative_path::{RelativePath, RelativePathBuf};
-    use {
-        db::{Db},
-        imp::FileResolverImp,
-        FileId, FileResolver,
-    };
-    use super::*;
-
-    #[derive(Debug)]
-    struct FileMap(im::HashMap<FileId, RelativePathBuf>);
-
-    impl FileResolver for FileMap {
-        fn file_stem(&self, file_id: FileId) -> String {
-            self.0[&file_id].file_stem().unwrap().to_string()
+salsa::query_group! {
+    pub(crate) trait ModulesDatabase: SyntaxDatabase {
+        fn module_tree(key: ()) -> Arc<ModuleTreeDescriptor> {
+            type ModuleTreeQuery;
         }
-        fn resolve(&self, file_id: FileId, rel: &RelativePath) -> Option<FileId> {
-            let path = self.0[&file_id].join(rel).normalize();
-            self.0.iter()
-                .filter_map(|&(id, ref p)| Some(id).filter(|_| p == &path))
-                .next()
+        fn module_descriptor(file_id: FileId) -> Arc<ModuleDescriptor> {
+            type ModuleDescriptorQuery;
         }
     }
+}
 
-    struct Fixture {
-        next_file_id: u32,
-        fm: im::HashMap<FileId, RelativePathBuf>,
-        db: Db,
-    }
-
-    impl Fixture {
-        fn new() -> Fixture {
-            Fixture {
-                next_file_id: 1,
-                fm: im::HashMap::new(),
-                db: Db::new(),
-            }
-        }
-        fn add_file(&mut self, path: &str, text: &str) -> FileId {
-            assert!(path.starts_with("/"));
-            let file_id = FileId(self.next_file_id);
-            self.next_file_id += 1;
-            self.fm.insert(file_id, RelativePathBuf::from(&path[1..]));
-            let mut new_state = self.db.state().clone();
-            new_state.file_map.insert(file_id, Arc::new(text.to_string()));
-            new_state.file_resolver = FileResolverImp::new(
-                Arc::new(FileMap(self.fm.clone()))
-            );
-            self.db = self.db.with_changes(new_state, &[file_id], true);
-            file_id
-        }
-        fn remove_file(&mut self, file_id: FileId) {
-            self.fm.remove(&file_id);
-            let mut new_state = self.db.state().clone();
-            new_state.file_map.remove(&file_id);
-            new_state.file_resolver = FileResolverImp::new(
-                Arc::new(FileMap(self.fm.clone()))
-            );
-            self.db = self.db.with_changes(new_state, &[file_id], true);
-        }
-        fn change_file(&mut self, file_id: FileId, new_text: &str) {
-            let mut new_state = self.db.state().clone();
-            new_state.file_map.insert(file_id, Arc::new(new_text.to_string()));
-            self.db = self.db.with_changes(new_state, &[file_id], false);
-        }
-        fn check_parent_modules(
-            &self,
-            file_id: FileId,
-            expected: &[FileId],
-            queries: &[(&'static str, u64)]
-        ) {
-            let (tree, events) = self.db.trace_query(|ctx| module_tree(ctx));
-            let actual = tree.parent_modules(file_id)
-                .into_iter()
-                .map(|link| link.owner(&tree))
-                .collect::<Vec<_>>();
-            assert_eq!(actual.as_slice(), expected);
-            let mut counts = HashMap::new();
-            events.into_iter()
-               .for_each(|event| *counts.entry(event).or_insert(0) += 1);
-            for &(query_id, expected_count) in queries.iter() {
-                let actual_count = *counts.get(&query_id).unwrap_or(&0);
-                assert_eq!(
-                    actual_count,
-                    expected_count,
-                    "counts for {} differ",
-                    query_id,
-                )
-            }
-
-        }
-    }
-
-    #[test]
-    fn test_parent_module() {
-        let mut f = Fixture::new();
-        let foo = f.add_file("/foo.rs", "");
-        f.check_parent_modules(foo, &[], &[("MODULE_DESCR", 1)]);
-
-        let lib = f.add_file("/lib.rs", "mod foo;");
-        f.check_parent_modules(foo, &[lib], &[("MODULE_DESCR", 1)]);
-        f.check_parent_modules(foo, &[lib], &[("MODULE_DESCR", 0)]);
-
-        f.change_file(lib, "");
-        f.check_parent_modules(foo, &[], &[("MODULE_DESCR", 1)]);
-
-        f.change_file(lib, "mod foo;");
-        f.check_parent_modules(foo, &[lib], &[("MODULE_DESCR", 1)]);
-
-        f.change_file(lib, "mod bar;");
-        f.check_parent_modules(foo, &[], &[("MODULE_DESCR", 1)]);
 
-        f.change_file(lib, "mod foo;");
-        f.check_parent_modules(foo, &[lib], &[("MODULE_DESCR", 1)]);
+fn module_descriptor(db: &impl ModulesDatabase, file_id: FileId) -> Arc<ModuleDescriptor> {
+    let file = db.file_syntax(file_id);
+    Arc::new(ModuleDescriptor::new(file.ast()))
+}
 
-        f.remove_file(lib);
-        f.check_parent_modules(foo, &[], &[("MODULE_DESCR", 0)]);
+fn module_tree(db: &impl ModulesDatabase, (): ()) -> Arc<ModuleTreeDescriptor> {
+    let file_set = db.file_set(());
+    let mut files = Vec::new();
+    for &file_id in file_set.files.iter() {
+        let module_descr = db.module_descriptor(file_id);
+        files.push((file_id, module_descr));
     }
+    let res = ModuleTreeDescriptor::new(files.iter().map(|(file_id, descr)| (*file_id, &**descr)), &file_set.resolver);
+    Arc::new(res)
 }
diff --git a/crates/ra_analysis/src/queries.rs b/crates/ra_analysis/src/queries.rs
deleted file mode 100644
index 062a2f420..000000000
--- a/crates/ra_analysis/src/queries.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use std::sync::Arc;
-use ra_syntax::File;
-use ra_editor::LineIndex;
-use {
-    FileId,
-    db::{Query, QueryCtx, QueryRegistry},
-    symbol_index::SymbolIndex,
-};
-
-pub(crate) use db::{file_text, file_set};
-
-pub(crate) fn file_syntax(ctx: QueryCtx, file_id: FileId) -> File {
-    (&*ctx.get(FILE_SYNTAX, file_id)).clone()
-}
-pub(crate) fn file_lines(ctx: QueryCtx, file_id: FileId) -> Arc<LineIndex> {
-    ctx.get(FILE_LINES, file_id)
-}
-pub(crate) fn file_symbols(ctx: QueryCtx, file_id: FileId) -> Arc<SymbolIndex> {
-    ctx.get(FILE_SYMBOLS, file_id)
-}
-
-const FILE_SYNTAX: Query<FileId, File> = Query(16, |ctx, file_id: &FileId| {
-    let text = file_text(ctx, *file_id);
-    File::parse(&*text)
-});
-const FILE_LINES: Query<FileId, LineIndex> = Query(17, |ctx, file_id: &FileId| {
-    let text = file_text(ctx, *file_id);
-    LineIndex::new(&*text)
-});
-const FILE_SYMBOLS: Query<FileId, SymbolIndex> = Query(18, |ctx, file_id: &FileId| {
-    let syntax = file_syntax(ctx, *file_id);
-    SymbolIndex::for_file(*file_id, syntax)
-});
-
-pub(crate) fn register_queries(reg: &mut QueryRegistry) {
-    reg.add(FILE_SYNTAX, "FILE_SYNTAX");
-    reg.add(FILE_LINES, "FILE_LINES");
-    reg.add(FILE_SYMBOLS, "FILE_SYMBOLS");
-}
diff --git a/crates/ra_analysis/src/roots.rs b/crates/ra_analysis/src/roots.rs
index 32a8c5bd0..76bcecd38 100644
--- a/crates/ra_analysis/src/roots.rs
+++ b/crates/ra_analysis/src/roots.rs
@@ -5,16 +5,18 @@ use std::{
 
 use once_cell::sync::OnceCell;
 use rayon::prelude::*;
-use rustc_hash::FxHashMap;
+use salsa::Database;
+use rustc_hash::{FxHashMap, FxHashSet};
 use ra_editor::LineIndex;
 use ra_syntax::File;
 
-use {
+use crate::{
     FileId,
     imp::FileResolverImp,
     symbol_index::SymbolIndex,
     descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
-    db::Db,
+    db::{self, FilesDatabase, SyntaxDatabase},
+    module_map::ModulesDatabase,
 };
 
 pub(crate) trait SourceRoot {
@@ -25,62 +27,68 @@ pub(crate) trait SourceRoot {
     fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>);
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub(crate) struct WritableSourceRoot {
-    db: Db,
+    db: db::RootDatabase,
 }
 
 impl WritableSourceRoot {
     pub fn apply_changes(
-        &self,
+        &mut self,
         changes: &mut dyn Iterator<Item=(FileId, Option<String>)>,
         file_resolver: Option<FileResolverImp>,
-    ) -> WritableSourceRoot {
-        let resolver_changed = file_resolver.is_some();
-        let mut changed_files = Vec::new();
-        let mut new_state = self.db.state().clone();
-
+    ) {
+        let mut changed = FxHashSet::default();
+        let mut removed = FxHashSet::default();
         for (file_id, text) in changes {
-            changed_files.push(file_id);
             match text {
-                Some(text) => {
-                    new_state.file_map.insert(file_id, Arc::new(text));
-                },
                 None => {
-                    new_state.file_map.remove(&file_id);
+                    removed.insert(file_id);
+                }
+                Some(text) => {
+                    self.db.query(db::FileTextQuery)
+                        .set(file_id, Arc::new(text));
+                    changed.insert(file_id);
                 }
             }
         }
-        if let Some(file_resolver) = file_resolver {
-            new_state.file_resolver = file_resolver
-        }
-        WritableSourceRoot {
-            db: self.db.with_changes(new_state, &changed_files, resolver_changed)
+        let file_set = self.db.file_set(());
+        let mut files: FxHashSet<FileId> = file_set
+            .files
+            .clone();
+        for file_id in removed {
+            files.remove(&file_id);
         }
+        files.extend(changed);
+        let resolver = file_resolver.unwrap_or_else(|| file_set.resolver.clone());
+        self.db.query(db::FileSetQuery)
+            .set((), Arc::new(db::FileSet { files, resolver }));
     }
 }
 
 impl SourceRoot for WritableSourceRoot {
     fn module_tree(&self) -> Arc<ModuleTreeDescriptor> {
-        self.db.make_query(::module_map::module_tree)
+        self.db.module_tree(())
     }
-
     fn contains(&self, file_id: FileId) -> bool {
-        self.db.state().file_map.contains_key(&file_id)
+        self.db.file_set(())
+            .files
+            .contains(&file_id)
     }
     fn lines(&self, file_id: FileId) -> Arc<LineIndex> {
-        self.db.make_query(|ctx| ::queries::file_lines(ctx, file_id))
+        self.db.file_lines(file_id)
     }
     fn syntax(&self, file_id: FileId) -> File {
-        self.db.make_query(|ctx| ::queries::file_syntax(ctx, file_id))
+        self.db.file_syntax(file_id)
     }
     fn symbols<'a>(&'a self, acc: &mut Vec<Arc<SymbolIndex>>) {
-        self.db.make_query(|ctx| {
-            let file_set = ::queries::file_set(ctx);
-            let syms = file_set.0.iter()
-                .map(|file_id| ::queries::file_symbols(ctx, *file_id));
-            acc.extend(syms);
-        });
+        let db = &self.db;
+        let symbols =  db.file_set(());
+        let symbols = symbols
+            .files
+            .iter()
+            .map(|&file_id| db.file_symbols(file_id));
+        acc.extend(symbols);
     }
 }
 
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index ffbb6a29f..54672fde4 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
 };
 use fst::{self, Streamer};
 use rayon::prelude::*;
-use {Query, FileId, JobToken};
+use crate::{Query, FileId, JobToken};
 
 #[derive(Debug)]
 pub(crate) struct SymbolIndex {
@@ -17,6 +17,15 @@ pub(crate) struct SymbolIndex {
     map: fst::Map,
 }
 
+impl PartialEq for SymbolIndex {
+    fn eq(&self, other: &SymbolIndex) -> bool {
+        self.symbols == other.symbols
+    }
+}
+
+impl Eq for SymbolIndex {
+}
+
 impl Hash for SymbolIndex {
     fn hash<H: Hasher>(&self, hasher: &mut H) {
         self.symbols.hash(hasher)
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index a886cd0ff..2d3679fa9 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -1,6 +1,8 @@
 extern crate relative_path;
 extern crate ra_analysis;
 extern crate rustc_hash;
+extern crate ra_editor;
+extern crate ra_syntax;
 extern crate test_utils;
 
 use std::{
@@ -9,8 +11,8 @@ use std::{
 
 use rustc_hash::FxHashMap;
 use relative_path::{RelativePath, RelativePathBuf};
-use ra_analysis::{Analysis, AnalysisHost, FileId, FileResolver, JobHandle, CrateGraph, CrateId};
-use test_utils::assert_eq_dbg;
+use ra_analysis::{Analysis, AnalysisHost, FileId, FileResolver, JobHandle, CrateGraph, CrateId, FnDescriptor};
+use test_utils::{assert_eq_dbg, extract_offset};
 
 #[derive(Debug)]
 struct FileMap(Vec<(FileId, RelativePathBuf)>);
@@ -39,7 +41,7 @@ impl FileResolver for FileMap {
     }
 }
 
-fn analysis_host(files: &'static [(&'static str, &'static str)]) -> AnalysisHost {
+fn analysis_host(files: &[(&str, &str)]) -> AnalysisHost {
     let mut host = AnalysisHost::new();
     let mut file_map = Vec::new();
     for (id, &(path, contents)) in files.iter().enumerate() {
@@ -53,10 +55,20 @@ fn analysis_host(files: &'static [(&'static str, &'static str)]) -> AnalysisHost
     host
 }
 
-fn analysis(files: &'static [(&'static str, &'static str)]) -> Analysis {
+fn analysis(files: &[(&str, &str)]) -> Analysis {
     analysis_host(files).analysis()
 }
 
+fn get_signature(text: &str) -> (FnDescriptor, Option<usize>) {
+    let (offset, code) = extract_offset(text);
+    let code = code.as_str();
+
+    let (_handle, token) = JobHandle::new();
+    let snap = analysis(&[("/lib.rs", code)]);
+
+    snap.resolve_callable(FileId(1), offset, &token).unwrap()
+}
+
 #[test]
 fn test_resolve_module() {
     let snap = analysis(&[
@@ -145,3 +157,85 @@ fn test_resolve_crate_root() {
         vec![CrateId(1)],
     );
 }
+
+#[test]
+fn test_fn_signature_two_args_first() {
+    let (desc, param) = get_signature(
+r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>3, ); }"#);
+
+    assert_eq!(desc.name, "foo".to_string());
+    assert_eq!(desc.params, vec!("x".to_string(),"y".to_string()));
+    assert_eq!(desc.ret_type, Some("-> u32".into()));
+    assert_eq!(param, Some(0));
+}
+
+#[test]
+fn test_fn_signature_two_args_second() {
+    let (desc, param) = get_signature(
+        r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3, <|>); }"#);
+
+    assert_eq!(desc.name, "foo".to_string());
+    assert_eq!(desc.params, vec!("x".to_string(),"y".to_string()));
+    assert_eq!(desc.ret_type, Some("-> u32".into()));
+    assert_eq!(param, Some(1));
+}
+
+#[test]
+fn test_fn_signature_for_impl() {
+    let (desc, param) = get_signature(
+r#"struct F; impl F { pub fn new() { F{}} }
+fn bar() {let _ : F = F::new(<|>);}"#);
+
+    assert_eq!(desc.name, "new".to_string());
+    assert_eq!(desc.params, Vec::<String>::new());
+    assert_eq!(desc.ret_type, None);
+    assert_eq!(param, None);
+}
+
+#[test]
+fn test_fn_signature_for_method_self() {
+    let (desc, param) = get_signature(
+r#"struct F;
+impl F {
+    pub fn new() -> F{
+        F{}
+    }
+
+    pub fn do_it(&self) {}
+}
+
+fn bar() {
+    let f : F = F::new();
+    f.do_it(<|>);
+}"#);
+
+    assert_eq!(desc.name, "do_it".to_string());
+    assert_eq!(desc.params, vec!["&self".to_string()]);
+    assert_eq!(desc.ret_type, None);
+    assert_eq!(param, None);
+}
+
+#[test]
+fn test_fn_signature_for_method_with_arg() {
+    let (desc, param) = get_signature(
+r#"struct F;
+impl F {
+    pub fn new() -> F{
+        F{}
+    }
+
+    pub fn do_it(&self, x: i32) {}
+}
+
+fn bar() {
+    let f : F = F::new();
+    f.do_it(<|>);
+}"#);
+
+    assert_eq!(desc.name, "do_it".to_string());
+    assert_eq!(desc.params, vec!["&self".to_string(), "x".to_string()]);
+    assert_eq!(desc.ret_type, None);
+    assert_eq!(param, Some(1));
+}
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 5e7bf3ed4..0b8d6f3dd 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "ra_cli"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/ra_editor/Cargo.toml b/crates/ra_editor/Cargo.toml
index 91cefc8d7..7791da156 100644
--- a/crates/ra_editor/Cargo.toml
+++ b/crates/ra_editor/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "ra_editor"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index 216d592ff..7b0a48c81 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
     },
 };
 
-use {EditBuilder, Edit, find_node_at_offset};
+use crate::{EditBuilder, Edit, find_node_at_offset};
 
 #[derive(Debug)]
 pub struct LocalEdit {
@@ -136,7 +136,7 @@ fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<Synta
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test_utils::{check_action, check_action_range};
+    use crate::test_utils::{check_action, check_action_range};
 
     #[test]
     fn test_swap_comma() {
diff --git a/crates/ra_editor/src/completion.rs b/crates/ra_editor/src/completion.rs
index 20b8484b3..b6095dca9 100644
--- a/crates/ra_editor/src/completion.rs
+++ b/crates/ra_editor/src/completion.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
     text_utils::is_subrange,
 };
 
-use {
+use crate::{
     AtomEdit, find_node_at_offset,
     scope::{FnScopes, ModuleScope},
 };
diff --git a/crates/ra_editor/src/edit.rs b/crates/ra_editor/src/edit.rs
index 2839ac20a..46e687319 100644
--- a/crates/ra_editor/src/edit.rs
+++ b/crates/ra_editor/src/edit.rs
@@ -1,4 +1,4 @@
-use {TextRange, TextUnit};
+use crate::{TextRange, TextUnit};
 use ra_syntax::{
     AtomEdit,
     text_utils::contains_offset_nonstrict,
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index 3aabd54ae..a1699d449 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -1,8 +1,10 @@
 use rustc_hash::FxHashSet;
 
 use ra_syntax::{
+    ast,
+    AstNode,
     File, TextRange, SyntaxNodeRef,
-    SyntaxKind,
+    SyntaxKind::{self, *},
     Direction,
 };
 
@@ -20,67 +22,97 @@ pub struct Fold {
 
 pub fn folding_ranges(file: &File) -> Vec<Fold> {
     let mut res = vec![];
-    let mut visited = FxHashSet::default();
+    let mut visited_comments = FxHashSet::default();
 
     for node in file.syntax().descendants() {
-        if visited.contains(&node) {
+        // Fold items that span multiple lines
+        if let Some(kind) = fold_kind(node.kind()) {
+            if has_newline(node) {
+                res.push(Fold { range: node.range(), kind });
+            }
+        }
+
+        // Also fold groups of comments
+        if visited_comments.contains(&node) {
             continue;
         }
+        if node.kind() == COMMENT {
+            contiguous_range_for_comment(node, &mut visited_comments)
+                .map(|range| res.push(Fold { range, kind: FoldKind::Comment }));
+        }
+    }
+
+    res
+}
 
-        let range_and_kind = match node.kind() {
-            SyntaxKind::COMMENT => (
-                contiguous_range_for(SyntaxKind::COMMENT, node, &mut visited),
-                Some(FoldKind::Comment),
-            ),
-            SyntaxKind::USE_ITEM => (
-                contiguous_range_for(SyntaxKind::USE_ITEM, node, &mut visited),
-                Some(FoldKind::Imports),
-            ),
-            _ => (None, None),
-        };
-
-        match range_and_kind {
-            (Some(range), Some(kind)) => {
-                res.push(Fold {
-                    range: range,
-                    kind: kind
-                });
+fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
+    match kind {
+        COMMENT => Some(FoldKind::Comment),
+        USE_ITEM => Some(FoldKind::Imports),
+        _ => None
+    }
+}
+
+fn has_newline(
+    node: SyntaxNodeRef,
+) -> bool {
+    for descendant in node.descendants() {
+        if let Some(ws) = ast::Whitespace::cast(descendant) {
+            if ws.has_newlines() {
+                return true;
+            }
+        } else if let Some(comment) = ast::Comment::cast(descendant) {
+            if comment.has_newlines() {
+                return true;
             }
-            _ => {}
         }
     }
 
-    res
+    false
 }
 
-fn contiguous_range_for<'a>(
-    kind: SyntaxKind,
-    node: SyntaxNodeRef<'a>,
+fn contiguous_range_for_comment<'a>(
+    first: SyntaxNodeRef<'a>,
     visited: &mut FxHashSet<SyntaxNodeRef<'a>>,
 ) -> Option<TextRange> {
-    visited.insert(node);
-
-    let left = node;
-    let mut right = node;
-    for node in node.siblings(Direction::Next) {
-        visited.insert(node);
-        match node.kind() {
-            SyntaxKind::WHITESPACE if !node.leaf_text().unwrap().as_str().contains("\n\n") => (),
-            k => {
-                if k == kind {
-                    right = node
-                } else {
-                    break;
-                }
+    visited.insert(first);
+
+    // Only fold comments of the same flavor
+    let group_flavor = ast::Comment::cast(first)?.flavor();
+
+    let mut last = first;
+    for node in first.siblings(Direction::Next) {
+        if let Some(ws) = ast::Whitespace::cast(node) {
+            // There is a blank line, which means the group ends here
+            if ws.count_newlines_lazy().take(2).count() == 2 {
+                break;
+            }
+
+            // Ignore whitespace without blank lines
+            continue;
+        }
+
+        match ast::Comment::cast(node) {
+            Some(next_comment) if next_comment.flavor() == group_flavor => {
+                visited.insert(node);
+                last = node;
+            }
+            // The comment group ends because either:
+            // * An element of a different kind was reached
+            // * A comment of a different flavor was reached
+            _ => {
+                break
             }
         }
     }
-    if left != right {
+
+    if first != last {
         Some(TextRange::from_to(
-            left.range().start(),
-            right.range().end(),
+            first.range().start(),
+            last.range().end(),
         ))
     } else {
+        // The group consists of only one element, therefore it cannot be folded
         None
     }
 }
@@ -88,52 +120,65 @@ fn contiguous_range_for<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use test_utils::extract_ranges;
+
+    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
+        let (ranges, text) = extract_ranges(text);
+        let file = File::parse(&text);
+        let folds = folding_ranges(&file);
+
+        assert_eq!(folds.len(), ranges.len());
+        for ((fold, range), fold_kind) in folds.into_iter().zip(ranges.into_iter()).zip(fold_kinds.into_iter()) {
+            assert_eq!(fold.range.start(), range.start());
+            assert_eq!(fold.range.end(), range.end());
+            assert_eq!(&fold.kind, fold_kind);
+        }
+    }
 
     #[test]
     fn test_fold_comments() {
         let text = r#"
-// Hello
+<|>// Hello
 // this is a multiline
 // comment
-//
+//<|>
 
 // But this is not
 
 fn main() {
-    // We should
+    <|>// We should
     // also
     // fold
-    // this one.
+    // this one.<|>
+    <|>//! But this one is different
+    //! because it has another flavor<|>
+    <|>/* As does this
+    multiline comment */<|>
 }"#;
 
-        let file = File::parse(&text);
-        let folds = folding_ranges(&file);
-        assert_eq!(folds.len(), 2);
-        assert_eq!(folds[0].range.start(), 1.into());
-        assert_eq!(folds[0].range.end(), 46.into());
-        assert_eq!(folds[0].kind, FoldKind::Comment);
-
-        assert_eq!(folds[1].range.start(), 84.into());
-        assert_eq!(folds[1].range.end(), 137.into());
-        assert_eq!(folds[1].kind, FoldKind::Comment);
+        let fold_kinds = &[
+            FoldKind::Comment,
+            FoldKind::Comment,
+            FoldKind::Comment,
+            FoldKind::Comment,
+        ];
+        do_check(text, fold_kinds);
     }
 
     #[test]
     fn test_fold_imports() {
         let text = r#"
-use std::str;
-use std::vec;
-use std::io as iop;
+<|>use std::{
+    str,
+    vec,
+    io as iop
+};<|>
 
 fn main() {
 }"#;
 
-        let file = File::parse(&text);
-        let folds = folding_ranges(&file);
-        assert_eq!(folds.len(), 1);
-        assert_eq!(folds[0].range.start(), 1.into());
-        assert_eq!(folds[0].range.end(), 48.into());
-        assert_eq!(folds[0].kind, FoldKind::Imports);
+        let folds = &[FoldKind::Imports];
+        do_check(text, folds);
     }
 
 
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index 710afc65d..bd61fd191 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -164,7 +164,7 @@ pub fn resolve_local_name(file: &File, offset: TextUnit, name_ref: ast::NameRef)
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test_utils::{assert_eq_dbg, extract_offset, add_cursor};
+    use crate::test_utils::{assert_eq_dbg, extract_offset, add_cursor};
 
     #[test]
     fn test_highlighting() {
diff --git a/crates/ra_editor/src/line_index.rs b/crates/ra_editor/src/line_index.rs
index 9cd8da3a8..95d64b8a8 100644
--- a/crates/ra_editor/src/line_index.rs
+++ b/crates/ra_editor/src/line_index.rs
@@ -1,7 +1,7 @@
 use superslice::Ext;
-use ::TextUnit;
+use crate::TextUnit;
 
-#[derive(Clone, Debug, Hash)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct LineIndex {
     newlines: Vec<TextUnit>,
 }
diff --git a/crates/ra_editor/src/scope/fn_scope.rs b/crates/ra_editor/src/scope/fn_scope.rs
index 9a48bda02..99d698b60 100644
--- a/crates/ra_editor/src/scope/fn_scope.rs
+++ b/crates/ra_editor/src/scope/fn_scope.rs
@@ -174,7 +174,7 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
             }
         }
         ast::Expr::LambdaExpr(e) => {
-            let mut scope = scopes.new_scope(scope);
+            let scope = scopes.new_scope(scope);
             scopes.add_params_bindings(scope, e.param_list());
             if let Some(body) = e.body() {
                 scopes.set_scope(body.syntax(), scope);
@@ -256,7 +256,7 @@ pub fn resolve_local_name<'a>(name_ref: ast::NameRef, scopes: &'a FnScopes) -> O
 mod tests {
     use super::*;
     use ra_syntax::File;
-    use {find_node_at_offset, test_utils::extract_offset};
+    use crate::{find_node_at_offset, test_utils::extract_offset};
 
     fn do_check(code: &str, expected: &[&str]) {
         let (off, code) = extract_offset(code);
diff --git a/crates/ra_editor/src/symbols.rs b/crates/ra_editor/src/symbols.rs
index e5cc5ca28..d9e4b2df7 100644
--- a/crates/ra_editor/src/symbols.rs
+++ b/crates/ra_editor/src/symbols.rs
@@ -6,7 +6,7 @@ use ra_syntax::{
         walk::{walk, WalkEvent},
     },
 };
-use TextRange;
+use crate::TextRange;
 
 #[derive(Debug, Clone)]
 pub struct StructureNode {
@@ -17,7 +17,7 @@ pub struct StructureNode {
     pub kind: SyntaxKind,
 }
 
-#[derive(Debug, Clone, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FileSymbol {
     pub name: SmolStr,
     pub node_range: TextRange,
diff --git a/crates/ra_editor/src/test_utils.rs b/crates/ra_editor/src/test_utils.rs
index c4ea4db6c..49eb530d5 100644
--- a/crates/ra_editor/src/test_utils.rs
+++ b/crates/ra_editor/src/test_utils.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{File, TextUnit, TextRange};
-pub use _test_utils::*;
-use LocalEdit;
+pub use crate::_test_utils::*;
+use crate::LocalEdit;
 
 pub fn check_action<F: Fn(&File, TextUnit) -> Option<LocalEdit>> (
     before: &str,
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 1dc658f9b..542b9e10b 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -10,7 +10,7 @@ use ra_syntax::{
     SyntaxKind::*,
 };
 
-use {LocalEdit, EditBuilder, find_node_at_offset};
+use crate::{LocalEdit, EditBuilder, find_node_at_offset};
 
 pub fn join_lines(file: &File, range: TextRange) -> LocalEdit {
     let range = if range.is_empty() {
@@ -244,7 +244,7 @@ fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test_utils::{check_action, extract_range, extract_offset, add_cursor};
+    use crate::test_utils::{check_action, extract_range, extract_offset, add_cursor};
 
     fn check_join_lines(before: &str, after: &str) {
         check_action(before, after, |file, offset| {
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 1fe6b2ebe..2b3257117 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "ra_lsp_server"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index 3c628f29c..5598ec75f 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -7,6 +7,7 @@ use languageserver_types::{
     TextDocumentSyncKind,
     ExecuteCommandOptions,
     CompletionOptions,
+    SignatureHelpOptions,
     DocumentOnTypeFormattingOptions,
 };
 
@@ -26,7 +27,9 @@ pub fn server_capabilities() -> ServerCapabilities {
             resolve_provider: None,
             trigger_characters: None,
         }),
-        signature_help_provider: None,
+        signature_help_provider: Some(SignatureHelpOptions {
+            trigger_characters: Some(vec!["(".to_string(), ",".to_string()])
+        }),
         definition_provider: Some(true),
         type_definition_provider: None,
         implementation_provider: None,
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 08a656569..a75b160c5 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -7,7 +7,7 @@ use ra_editor::{LineIndex, LineCol, Edit, AtomEdit};
 use ra_syntax::{SyntaxKind, TextUnit, TextRange};
 use ra_analysis::{FileId, SourceChange, SourceFileEdit, FileSystemEdit};
 
-use {
+use crate::{
     Result,
     server_world::ServerWorld,
     req,
@@ -299,7 +299,7 @@ pub fn to_location(
         Ok(loc)
 }
 
-pub trait MapConvWith<'a>: Sized {
+pub trait MapConvWith<'a>: Sized + 'a {
     type Ctx;
     type Output;
 
@@ -309,7 +309,7 @@ pub trait MapConvWith<'a>: Sized {
 }
 
 impl<'a, I> MapConvWith<'a> for I
-    where I: Iterator,
+    where I: Iterator + 'a,
           I::Item: ConvWith
 {
     type Ctx = <I::Item as ConvWith>::Ctx;
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 60652d55e..7224b1476 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -34,5 +34,7 @@ mod project_model;
 pub mod thread_watcher;
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
-pub use caps::server_capabilities;
-pub use main_loop::main_loop;
+pub use crate::{
+    main_loop::main_loop,
+    caps::server_capabilities,
+};
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index ab8be15e9..5acb39b60 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -13,7 +13,7 @@ use ra_syntax::{
     text_utils::contains_offset_nonstrict
 };
 
-use ::{
+use crate::{
     req::{self, Decoration}, Result,
     conv::{Conv, ConvWith, TryConvWith, MapConvWith, to_location},
     server_world::ServerWorld,
@@ -411,6 +411,42 @@ pub fn handle_folding_range(
     Ok(res)
 }
 
+pub fn handle_signature_help(
+    world: ServerWorld,
+    params: req::TextDocumentPositionParams,
+    token: JobToken,
+) -> Result<Option<req::SignatureHelp>> {
+    use languageserver_types::{ParameterInformation, SignatureInformation};
+
+    let file_id = params.text_document.try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(file_id);
+    let offset = params.position.conv_with(&line_index);
+
+    if let Some((descriptor, active_param)) = world.analysis().resolve_callable(file_id, offset, &token) {
+        let parameters : Vec<ParameterInformation> =
+            descriptor.params.iter().map(|param|
+                ParameterInformation {
+                    label: param.clone(),
+                    documentation: None
+                }
+            ).collect();
+
+        let sig_info = SignatureInformation {
+            label: descriptor.label,
+            documentation: None,
+            parameters: Some(parameters)
+        };
+
+        Ok(Some(req::SignatureHelp {
+            signatures: vec![sig_info],
+            active_signature: Some(0),
+            active_parameter: active_param.map(|a| a as u64)
+        }))
+    } else {
+        Ok(None)
+    }
+}
+
 pub fn handle_code_action(
     world: ServerWorld,
     params: req::CodeActionParams,
@@ -442,7 +478,7 @@ pub fn handle_code_action(
 }
 
 pub fn publish_diagnostics(
-    world: ServerWorld,
+    world: &ServerWorld,
     file_id: FileId,
 ) -> Result<req::PublishDiagnosticsParams> {
     let uri = world.file_id_to_uri(file_id)?;
@@ -461,7 +497,7 @@ pub fn publish_diagnostics(
 }
 
 pub fn publish_decorations(
-    world: ServerWorld,
+    world: &ServerWorld,
     file_id: FileId,
 ) -> Result<req::PublishDecorationsParams> {
     let uri = world.file_id_to_uri(file_id)?;
diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop/mod.rs
index 402615e42..cf2477cb5 100644
--- a/crates/ra_lsp_server/src/main_loop/mod.rs
+++ b/crates/ra_lsp_server/src/main_loop/mod.rs
@@ -16,7 +16,7 @@ use gen_lsp_server::{
 };
 use rustc_hash::FxHashMap;
 
-use {
+use crate::{
     req,
     Result,
     vfs::{self, FileEvent},
@@ -255,6 +255,7 @@ fn on_request(
         .on::<req::Completion>(handlers::handle_completion)?
         .on::<req::CodeActionRequest>(handlers::handle_code_action)?
         .on::<req::FoldingRangeRequest>(handlers::handle_folding_range)?
+        .on::<req::SignatureHelpRequest>(handlers::handle_signature_help)?
         .finish();
     match req {
         Ok((id, handle)) => {
@@ -390,7 +391,7 @@ fn update_file_notifications_on_threadpool(
 ) {
     pool.spawn(move || {
         for file_id in subscriptions {
-            match handlers::publish_diagnostics(world.clone(), file_id) {
+            match handlers::publish_diagnostics(&world, file_id) {
                 Err(e) => {
                     error!("failed to compute diagnostics: {:?}", e)
                 }
@@ -399,7 +400,7 @@ fn update_file_notifications_on_threadpool(
                     sender.send(Task::Notify(not));
                 }
             }
-            match handlers::publish_decorations(world.clone(), file_id) {
+            match handlers::publish_decorations(&world, file_id) {
                 Err(e) => {
                     error!("failed to compute decorations: {:?}", e)
                 }
diff --git a/crates/ra_lsp_server/src/project_model.rs b/crates/ra_lsp_server/src/project_model.rs
index 43e4fd654..c144d9596 100644
--- a/crates/ra_lsp_server/src/project_model.rs
+++ b/crates/ra_lsp_server/src/project_model.rs
@@ -5,7 +5,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use cargo_metadata::{metadata_run, CargoOpt};
 use ra_syntax::SmolStr;
 
-use {
+use crate::{
     Result,
     thread_watcher::{Worker, ThreadWatcher},
 };
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index f80957589..1630edf7f 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -14,6 +14,7 @@ pub use languageserver_types::{
     CompletionParams, CompletionResponse,
     DocumentOnTypeFormattingParams,
     TextDocumentEdit,
+    SignatureHelp, Hover
 };
 
 pub enum SyntaxTree {}
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index c4cdf83d4..9b3013ae8 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use languageserver_types::Url;
 use ra_analysis::{FileId, AnalysisHost, Analysis, CrateGraph, CrateId, LibraryData, FileResolver};
 
-use {
+use crate::{
     Result,
     path_map::{PathMap, Root},
     vfs::{FileEvent, FileEventKind},
@@ -23,7 +23,6 @@ pub struct ServerWorldState {
     pub mem_map: FxHashMap<FileId, Option<String>>,
 }
 
-#[derive(Clone)]
 pub struct ServerWorld {
     pub workspaces: Arc<Vec<CargoWorkspace>>,
     pub analysis: Analysis,
diff --git a/crates/ra_lsp_server/src/thread_watcher.rs b/crates/ra_lsp_server/src/thread_watcher.rs
index 86a3a91e0..3257effcb 100644
--- a/crates/ra_lsp_server/src/thread_watcher.rs
+++ b/crates/ra_lsp_server/src/thread_watcher.rs
@@ -1,7 +1,7 @@
 use std::thread;
 use crossbeam_channel::{bounded, unbounded, Sender, Receiver};
 use drop_bomb::DropBomb;
-use Result;
+use crate::Result;
 
 pub struct Worker<I, O> {
     pub inp: Sender<I>,
diff --git a/crates/ra_lsp_server/src/vfs.rs b/crates/ra_lsp_server/src/vfs.rs
index a1c1783f2..d8f9b1aac 100644
--- a/crates/ra_lsp_server/src/vfs.rs
+++ b/crates/ra_lsp_server/src/vfs.rs
@@ -5,7 +5,7 @@ use std::{
 
 use walkdir::WalkDir;
 
-use {
+use crate::{
     thread_watcher::{Worker, ThreadWatcher},
 };
 
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index dced45f55..7265b5999 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -12,7 +12,7 @@ mod support;
 
 use ra_lsp_server::req::{Runnables, RunnablesParams};
 
-use support::project;
+use crate::support::project;
 
 
 const LOG: &'static str = "";
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/ra_lsp_server/tests/heavy_tests/support.rs
index 8fe2aa816..d1339f62f 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/support.rs
@@ -25,7 +25,7 @@ use ra_lsp_server::{main_loop, req, thread_watcher::{ThreadWatcher, Worker}};
 
 pub fn project(fixture: &str) -> Server {
     static INIT: Once = Once::new();
-    INIT.call_once(|| Logger::with_env_or_str(::LOG).start().unwrap());
+    INIT.call_once(|| Logger::with_env_or_str(crate::LOG).start().unwrap());
 
     let tmp_dir = TempDir::new("test-project")
         .unwrap();
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 6345e4725..34bb1c591 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "ra_syntax"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/ra_syntax/src/algo/mod.rs b/crates/ra_syntax/src/algo/mod.rs
index a6678093d..e686a5704 100644
--- a/crates/ra_syntax/src/algo/mod.rs
+++ b/crates/ra_syntax/src/algo/mod.rs
@@ -1,7 +1,7 @@
 pub mod walk;
 pub mod visit;
 
-use {
+use crate::{
     SyntaxNodeRef, TextUnit, TextRange,
     text_utils::{contains_offset_nonstrict, is_subrange},
 };
diff --git a/crates/ra_syntax/src/algo/visit.rs b/crates/ra_syntax/src/algo/visit.rs
index 9f1c127c7..1ae988a87 100644
--- a/crates/ra_syntax/src/algo/visit.rs
+++ b/crates/ra_syntax/src/algo/visit.rs
@@ -1,5 +1,5 @@
 use std::marker::PhantomData;
-use {SyntaxNodeRef, AstNode};
+use crate::{SyntaxNodeRef, AstNode};
 
 
 pub fn visitor<'a, T>() -> impl Visitor<'a, Output=T> {
diff --git a/crates/ra_syntax/src/algo/walk.rs b/crates/ra_syntax/src/algo/walk.rs
index 8e294d965..d34415626 100644
--- a/crates/ra_syntax/src/algo/walk.rs
+++ b/crates/ra_syntax/src/algo/walk.rs
@@ -1,4 +1,4 @@
-use {
+use crate::{
     SyntaxNodeRef,
     algo::generate,
 };
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index ef7b5b1a1..160d186b8 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,7 +1,7 @@
 // This file is automatically generated based on the file `./generated.rs.tera` when `cargo gen-kinds` is run
 // Do not edit manually
 
-use {
+use crate::{
     ast,
     SyntaxNodeRef, AstNode,
     SyntaxKind::*,
@@ -1387,7 +1387,11 @@ impl<'a> AstNode<'a> for PathExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> PathExpr<'a> {}
+impl<'a> PathExpr<'a> {
+    pub fn path(self) -> Option<Path<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // PathPat
 #[derive(Debug, Clone, Copy)]
@@ -2193,3 +2197,21 @@ impl<'a> WhileExpr<'a> {
     }
 }
 
+// Whitespace
+#[derive(Debug, Clone, Copy)]
+pub struct Whitespace<'a> {
+    syntax: SyntaxNodeRef<'a>,
+}
+
+impl<'a> AstNode<'a> for Whitespace<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            WHITESPACE => Some(Whitespace { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<'a> Whitespace<'a> {}
+
diff --git a/crates/ra_syntax/src/ast/generated.rs.tera b/crates/ra_syntax/src/ast/generated.rs.tera
index ffa9c4134..5cb7a35ed 100644
--- a/crates/ra_syntax/src/ast/generated.rs.tera
+++ b/crates/ra_syntax/src/ast/generated.rs.tera
@@ -3,7 +3,7 @@ the below applies to the result of this template
 #}// This file is automatically generated based on the file `./generated.rs.tera` when `cargo gen-kinds` is run
 // Do not edit manually
 
-use {
+use crate::{
     ast,
     SyntaxNodeRef, AstNode,
     SyntaxKind::*,
diff --git a/crates/ra_syntax/src/ast/mod.rs b/crates/ra_syntax/src/ast/mod.rs
index 10dac72e5..88193a1ed 100644
--- a/crates/ra_syntax/src/ast/mod.rs
+++ b/crates/ra_syntax/src/ast/mod.rs
@@ -4,7 +4,7 @@ use std::marker::PhantomData;
 
 use itertools::Itertools;
 
-use {
+use crate::{
     SmolStr, SyntaxNodeRef, SyntaxKind::*,
     yellow::{RefRoot, SyntaxNodeChildren},
 };
@@ -100,8 +100,8 @@ impl<'a> Lifetime<'a> {
 }
 
 impl<'a> Comment<'a> {
-    pub fn text(&self) -> SmolStr {
-        self.syntax().leaf_text().unwrap().clone()
+    pub fn text(&self) -> &SmolStr {
+        self.syntax().leaf_text().unwrap()
     }
 
     pub fn flavor(&self) -> CommentFlavor {
@@ -120,9 +120,17 @@ impl<'a> Comment<'a> {
     pub fn prefix(&self) -> &'static str {
         self.flavor().prefix()
     }
+
+    pub fn count_newlines_lazy(&self) -> impl Iterator<Item = &()> {
+        self.text().chars().filter(|&c| c == '\n').map(|_| &())
+    }
+
+    pub fn has_newlines(&self) -> bool {
+        self.count_newlines_lazy().count() > 0
+    }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum CommentFlavor {
     Line,
     Doc,
@@ -142,6 +150,20 @@ impl CommentFlavor {
     }
 }
 
+impl<'a> Whitespace<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+
+    pub fn count_newlines_lazy(&self) -> impl Iterator<Item = &()> {
+        self.text().chars().filter(|&c| c == '\n').map(|_| &())
+    }
+
+    pub fn has_newlines(&self) -> bool {
+        self.count_newlines_lazy().count() > 0
+    }
+}
+
 impl<'a> Name<'a> {
     pub fn text(&self) -> SmolStr {
         let ident = self.syntax().first_child()
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 9da0c2c13..ea8063d3b 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -342,7 +342,7 @@ Grammar(
         "TupleExpr": (),
         "ArrayExpr": (),
         "ParenExpr": (),
-        "PathExpr": (),
+        "PathExpr": (options: ["Path"]),
         "LambdaExpr": (
             options: [
                 "ParamList",
@@ -538,5 +538,6 @@ Grammar(
             options: [ "NameRef" ]
         ),
         "Comment": (),
+        "Whitespace": (),
     },
 )
diff --git a/crates/ra_syntax/src/grammar/expressions/atom.rs b/crates/ra_syntax/src/grammar/expressions/atom.rs
index a720d255f..e21de68c5 100644
--- a/crates/ra_syntax/src/grammar/expressions/atom.rs
+++ b/crates/ra_syntax/src/grammar/expressions/atom.rs
@@ -30,7 +30,7 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
     token_set_union![
         LITERAL_FIRST,
         token_set![L_CURLY, L_PAREN, L_BRACK, PIPE, MOVE_KW, IF_KW, WHILE_KW, MATCH_KW, UNSAFE_KW,
-                   RETURN_KW, IDENT, SELF_KW, SUPER_KW, COLONCOLON, BREAK_KW, CONTINUE_KW, LIFETIME ],
+                   RETURN_KW, IDENT, SELF_KW, SUPER_KW, CRATE_KW, COLONCOLON, BREAK_KW, CONTINUE_KW, LIFETIME ],
     ];
 
 const EXPR_RECOVERY_SET: TokenSet =
diff --git a/crates/ra_syntax/src/grammar/mod.rs b/crates/ra_syntax/src/grammar/mod.rs
index 2cb11dc1e..1199ba230 100644
--- a/crates/ra_syntax/src/grammar/mod.rs
+++ b/crates/ra_syntax/src/grammar/mod.rs
@@ -31,7 +31,7 @@ mod type_args;
 mod type_params;
 mod types;
 
-use {
+use crate::{
     token_set::TokenSet,
     parser_api::{Marker, CompletedMarker, Parser},
     SyntaxKind::{self, *},
diff --git a/crates/ra_syntax/src/lexer/comments.rs b/crates/ra_syntax/src/lexer/comments.rs
index eb417c2dc..afe6886a1 100644
--- a/crates/ra_syntax/src/lexer/comments.rs
+++ b/crates/ra_syntax/src/lexer/comments.rs
@@ -1,6 +1,6 @@
-use lexer::ptr::Ptr;
+use crate::lexer::ptr::Ptr;
 
-use SyntaxKind::{self, *};
+use crate::SyntaxKind::{self, *};
 
 pub(crate) fn scan_shebang(ptr: &mut Ptr) -> bool {
     if ptr.at_str("!/") {
diff --git a/crates/ra_syntax/src/lexer/mod.rs b/crates/ra_syntax/src/lexer/mod.rs
index 3e11db88b..9dc0b63d6 100644
--- a/crates/ra_syntax/src/lexer/mod.rs
+++ b/crates/ra_syntax/src/lexer/mod.rs
@@ -4,7 +4,7 @@ mod numbers;
 mod ptr;
 mod strings;
 
-use {
+use crate::{
     SyntaxKind::{self, *},
     TextUnit,
 };
diff --git a/crates/ra_syntax/src/lexer/numbers.rs b/crates/ra_syntax/src/lexer/numbers.rs
index 22e7d4e99..46daf5e52 100644
--- a/crates/ra_syntax/src/lexer/numbers.rs
+++ b/crates/ra_syntax/src/lexer/numbers.rs
@@ -1,7 +1,7 @@
-use lexer::classes::*;
-use lexer::ptr::Ptr;
+use crate::lexer::classes::*;
+use crate::lexer::ptr::Ptr;
 
-use SyntaxKind::{self, *};
+use crate::SyntaxKind::{self, *};
 
 pub(crate) fn scan_number(c: char, ptr: &mut Ptr) -> SyntaxKind {
     if c == '0' {
diff --git a/crates/ra_syntax/src/lexer/ptr.rs b/crates/ra_syntax/src/lexer/ptr.rs
index c9a5354ea..c4708cb1c 100644
--- a/crates/ra_syntax/src/lexer/ptr.rs
+++ b/crates/ra_syntax/src/lexer/ptr.rs
@@ -1,4 +1,4 @@
-use TextUnit;
+use crate::TextUnit;
 
 use std::str::Chars;
 
diff --git a/crates/ra_syntax/src/lexer/strings.rs b/crates/ra_syntax/src/lexer/strings.rs
index 5ff483d14..bceacdcac 100644
--- a/crates/ra_syntax/src/lexer/strings.rs
+++ b/crates/ra_syntax/src/lexer/strings.rs
@@ -1,6 +1,6 @@
-use SyntaxKind::{self, *};
+use crate::SyntaxKind::{self, *};
 
-use lexer::ptr::Ptr;
+use crate::lexer::ptr::Ptr;
 
 pub(crate) fn is_string_literal_start(c: char, c1: Option<char>, c2: Option<char>) -> bool {
     match (c, c1, c2) {
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 703469629..7eba5ee61 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -46,7 +46,7 @@ mod yellow;
 pub mod utils;
 pub mod text_utils;
 
-pub use {
+pub use crate::{
     rowan::{SmolStr, TextRange, TextUnit},
     ast::AstNode,
     lexer::{tokenize, Token},
@@ -55,11 +55,11 @@ pub use {
     reparsing::AtomEdit,
 };
 
-use {
+use crate::{
     yellow::{GreenNode},
 };
 
-#[derive(Clone, Debug, Hash)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct File {
     root: SyntaxNode
 }
diff --git a/crates/ra_syntax/src/parser_api.rs b/crates/ra_syntax/src/parser_api.rs
index 772d753af..cc23bb75e 100644
--- a/crates/ra_syntax/src/parser_api.rs
+++ b/crates/ra_syntax/src/parser_api.rs
@@ -1,4 +1,4 @@
-use {
+use crate::{
     token_set::TokenSet,
     parser_impl::ParserImpl,
     SyntaxKind::{self, ERROR},
diff --git a/crates/ra_syntax/src/parser_impl/event.rs b/crates/ra_syntax/src/parser_impl/event.rs
index 95e5ce4cc..928d2cc7a 100644
--- a/crates/ra_syntax/src/parser_impl/event.rs
+++ b/crates/ra_syntax/src/parser_impl/event.rs
@@ -8,7 +8,7 @@
 //! `start node`, `finish node`, and `FileBuilder` converts
 //! this stream to a real tree.
 use std::mem;
-use {
+use crate::{
     TextUnit, TextRange, SmolStr,
     lexer::Token,
     parser_impl::Sink,
diff --git a/crates/ra_syntax/src/parser_impl/input.rs b/crates/ra_syntax/src/parser_impl/input.rs
index c0fe4d488..ac6d900d8 100644
--- a/crates/ra_syntax/src/parser_impl/input.rs
+++ b/crates/ra_syntax/src/parser_impl/input.rs
@@ -1,4 +1,4 @@
-use {lexer::Token, SyntaxKind, SyntaxKind::EOF, TextRange, TextUnit};
+use crate::{lexer::Token, SyntaxKind, SyntaxKind::EOF, TextRange, TextUnit};
 
 use std::ops::{Add, AddAssign};
 
diff --git a/crates/ra_syntax/src/parser_impl/mod.rs b/crates/ra_syntax/src/parser_impl/mod.rs
index 8d74cef0e..c2a6448e7 100644
--- a/crates/ra_syntax/src/parser_impl/mod.rs
+++ b/crates/ra_syntax/src/parser_impl/mod.rs
@@ -3,7 +3,7 @@ mod input;
 
 use std::cell::Cell;
 
-use {
+use crate::{
     TextUnit, SmolStr,
     lexer::Token,
     parser_api::Parser,
@@ -13,7 +13,7 @@ use {
     },
 };
 
-use SyntaxKind::{self, EOF, TOMBSTONE};
+use crate::SyntaxKind::{self, EOF, TOMBSTONE};
 
 pub(crate) trait Sink {
     type Tree;
diff --git a/crates/ra_syntax/src/reparsing.rs b/crates/ra_syntax/src/reparsing.rs
index d8b6a6a10..16272fe88 100644
--- a/crates/ra_syntax/src/reparsing.rs
+++ b/crates/ra_syntax/src/reparsing.rs
@@ -1,14 +1,14 @@
-use algo;
-use grammar;
-use lexer::{tokenize, Token};
-use yellow::{self, GreenNode, SyntaxNodeRef, SyntaxError};
-use parser_impl;
-use parser_api::Parser;
-use {
+use crate::algo;
+use crate::grammar;
+use crate::lexer::{tokenize, Token};
+use crate::yellow::{self, GreenNode, SyntaxNodeRef, SyntaxError};
+use crate::parser_impl;
+use crate::parser_api::Parser;
+use crate::{
     TextUnit, TextRange,
     SyntaxKind::*,
 };
-use text_utils::replace_range;
+use crate::text_utils::replace_range;
 
 #[derive(Debug, Clone)]
 pub struct AtomEdit {
diff --git a/crates/ra_syntax/src/syntax_kinds/mod.rs b/crates/ra_syntax/src/syntax_kinds/mod.rs
index 332cd13ac..3041e5633 100644
--- a/crates/ra_syntax/src/syntax_kinds/mod.rs
+++ b/crates/ra_syntax/src/syntax_kinds/mod.rs
@@ -1,7 +1,7 @@
 mod generated;
 
 use std::fmt;
-use SyntaxKind::*;
+use crate::SyntaxKind::*;
 
 pub use self::generated::SyntaxKind;
 
diff --git a/crates/ra_syntax/src/text_utils.rs b/crates/ra_syntax/src/text_utils.rs
index 58ae1e43e..adf26ef30 100644
--- a/crates/ra_syntax/src/text_utils.rs
+++ b/crates/ra_syntax/src/text_utils.rs
@@ -1,4 +1,4 @@
-use {TextRange, TextUnit};
+use crate::{TextRange, TextUnit};
 
 pub fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
     range.start() <= offset && offset <= range.end()
diff --git a/crates/ra_syntax/src/token_set.rs b/crates/ra_syntax/src/token_set.rs
index c83fba81b..d407dfa48 100644
--- a/crates/ra_syntax/src/token_set.rs
+++ b/crates/ra_syntax/src/token_set.rs
@@ -1,4 +1,4 @@
-use SyntaxKind;
+use crate::SyntaxKind;
 
 #[derive(Clone, Copy)]
 pub(crate) struct TokenSet(pub(crate) u128);
@@ -29,7 +29,7 @@ macro_rules! token_set_union {
 
 #[test]
 fn token_set_works_for_tokens() {
-    use SyntaxKind::*;
+    use crate::SyntaxKind::*;
     let ts = token_set! { EOF, SHEBANG };
     assert!(ts.contains(EOF));
     assert!(ts.contains(SHEBANG));
diff --git a/crates/ra_syntax/src/utils.rs b/crates/ra_syntax/src/utils.rs
index e274f7471..df1f4b372 100644
--- a/crates/ra_syntax/src/utils.rs
+++ b/crates/ra_syntax/src/utils.rs
@@ -1,5 +1,5 @@
 use std::fmt::Write;
-use {
+use crate::{
     algo::walk::{walk, WalkEvent},
     SyntaxKind, File, SyntaxNodeRef
 };
diff --git a/crates/ra_syntax/src/yellow/builder.rs b/crates/ra_syntax/src/yellow/builder.rs
index c307b2bd0..67a1a382b 100644
--- a/crates/ra_syntax/src/yellow/builder.rs
+++ b/crates/ra_syntax/src/yellow/builder.rs
@@ -1,5 +1,5 @@
 use rowan::GreenNodeBuilder;
-use {
+use crate::{
     TextUnit, SmolStr,
     parser_impl::Sink,
     yellow::{GreenNode, SyntaxError, RaTypes},
diff --git a/crates/ra_syntax/src/yellow/mod.rs b/crates/ra_syntax/src/yellow/mod.rs
index 710320f47..ab9bca0f0 100644
--- a/crates/ra_syntax/src/yellow/mod.rs
+++ b/crates/ra_syntax/src/yellow/mod.rs
@@ -6,7 +6,7 @@ use std::{
     hash::{Hash, Hasher},
 };
 use rowan::Types;
-use {SyntaxKind, TextUnit, TextRange, SmolStr};
+use crate::{SyntaxKind, TextUnit, TextRange, SmolStr};
 use self::syntax_text::SyntaxText;
 
 pub use rowan::{TreeRoot};
@@ -70,16 +70,16 @@ impl<'a> SyntaxNodeRef<'a> {
         self.0.leaf_text()
     }
     pub fn ancestors(self) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
-        ::algo::generate(Some(self), |&node| node.parent())
+        crate::algo::generate(Some(self), |&node| node.parent())
     }
     pub fn descendants(self) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
-        ::algo::walk::walk(self).filter_map(|event| match event {
-            ::algo::walk::WalkEvent::Enter(node) => Some(node),
-            ::algo::walk::WalkEvent::Exit(_) => None,
+        crate::algo::walk::walk(self).filter_map(|event| match event {
+            crate::algo::walk::WalkEvent::Enter(node) => Some(node),
+            crate::algo::walk::WalkEvent::Exit(_) => None,
         })
     }
     pub fn siblings(self, direction: Direction) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
-        ::algo::generate(Some(self), move |&node| match direction {
+        crate::algo::generate(Some(self), move |&node| match direction {
             Direction::Next => node.next_sibling(),
             Direction::Prev => node.prev_sibling(),
         })
@@ -156,7 +156,7 @@ impl<R: TreeRoot<RaTypes>> Iterator for SyntaxNodeChildren<R> {
 
 
 fn has_short_text(kind: SyntaxKind) -> bool {
-    use SyntaxKind::*;
+    use crate::SyntaxKind::*;
     match kind {
         IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true,
         _ => false,
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index 0db1049de..ae33b993d 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -2,7 +2,7 @@ use std::{
     fmt, ops,
 };
 
-use {
+use crate::{
     SyntaxNodeRef, TextRange, TextUnit,
     text_utils::{intersect, contains_offset_nonstrict},
 };
diff --git a/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.rs b/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.rs
new file mode 100644
index 000000000..f1ed30220
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.rs
@@ -0,0 +1,3 @@
+fn main() {
+    make_query(crate::module_map::module_tree);
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.txt b/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.txt
new file mode 100644
index 000000000..364315180
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0035_crate_path_in_call.txt
@@ -0,0 +1,41 @@
+ROOT@[0; 62)
+  FN_DEF@[0; 61)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK@[10; 61)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      EXPR_STMT@[16; 59)
+        CALL_EXPR@[16; 58)
+          PATH_EXPR@[16; 26)
+            PATH@[16; 26)
+              PATH_SEGMENT@[16; 26)
+                NAME_REF@[16; 26)
+                  IDENT@[16; 26) "make_query"
+          ARG_LIST@[26; 58)
+            L_PAREN@[26; 27)
+            PATH_EXPR@[27; 57)
+              PATH@[27; 57)
+                PATH@[27; 44)
+                  PATH@[27; 32)
+                    PATH_SEGMENT@[27; 32)
+                      CRATE_KW@[27; 32)
+                  COLONCOLON@[32; 34)
+                  PATH_SEGMENT@[34; 44)
+                    NAME_REF@[34; 44)
+                      IDENT@[34; 44) "module_map"
+                COLONCOLON@[44; 46)
+                PATH_SEGMENT@[46; 57)
+                  NAME_REF@[46; 57)
+                    IDENT@[46; 57) "module_tree"
+            R_PAREN@[57; 58)
+        SEMI@[58; 59)
+      WHITESPACE@[59; 60)
+      R_CURLY@[60; 61)
+  WHITESPACE@[61; 62)
diff --git a/crates/salsa/Cargo.toml b/crates/salsa/Cargo.toml
deleted file mode 100644
index 9eb83234f..000000000
--- a/crates/salsa/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "salsa"
-version = "0.1.0"
-authors = ["Aleksey Kladov <[email protected]>"]
-
-[dependencies]
-parking_lot = "0.6.3"
-im = "12.0.0"
diff --git a/crates/salsa/src/lib.rs b/crates/salsa/src/lib.rs
deleted file mode 100644
index 35deed374..000000000
--- a/crates/salsa/src/lib.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-extern crate im;
-extern crate parking_lot;
-
-use std::{
-    sync::Arc,
-    collections::{HashSet, HashMap},
-    cell::RefCell,
-};
-use parking_lot::Mutex;
-
-pub type GroundQueryFn<T, D> = Box<Fn(&T, &D) -> (D, OutputFingerprint) + Send + Sync + 'static>;
-pub type QueryFn<T, D> = Box<Fn(&QueryCtx<T, D>, &D) -> (D, OutputFingerprint) + Send + Sync + 'static>;
-
-#[derive(Debug)]
-pub struct Db<T, D> {
-    db: Arc<DbState<T, D>>,
-    query_config: Arc<QueryConfig<T, D>>,
-}
-
-pub struct QueryConfig<T, D> {
-    ground_fn: HashMap<QueryTypeId, GroundQueryFn<T, D>>,
-    query_fn: HashMap<QueryTypeId, QueryFn<T, D>>,
-}
-
-impl<T, D> ::std::fmt::Debug for QueryConfig<T, D> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        ::std::fmt::Display::fmt("QueryConfig { ... }", f)
-    }
-}
-
-#[derive(Debug)]
-struct DbState<T, D> {
-    ground_data: T,
-    gen: Gen,
-    graph: Mutex<im::HashMap<QueryId, (Gen, Arc<QueryRecord<D>>)>>,
-}
-
-#[derive(Debug)]
-struct QueryRecord<D> {
-    params: D,
-    output: D,
-    output_fingerprint: OutputFingerprint,
-    deps: Vec<(QueryId, OutputFingerprint)>,
-}
-
-impl<T, D> DbState<T, D> {
-    fn record(
-        &self,
-        query_id: QueryId,
-        params: D,
-        output: D,
-        output_fingerprint: OutputFingerprint,
-        deps: Vec<(QueryId, OutputFingerprint)>,
-    ) {
-        let gen = self.gen;
-        let record = QueryRecord {
-            params,
-            output,
-            output_fingerprint,
-            deps,
-        };
-        self.graph.lock().insert(query_id, (gen, Arc::new(record)));
-    }
-}
-
-impl<T, D> QueryConfig<T, D> {
-    pub fn new() -> Self {
-        QueryConfig {
-            ground_fn: HashMap::new(),
-            query_fn: HashMap::new(),
-        }
-    }
-    pub fn with_ground_query(
-        mut self,
-        query_type: QueryTypeId,
-        query_fn: GroundQueryFn<T, D>
-    ) -> Self {
-        let prev = self.ground_fn.insert(query_type, query_fn);
-        assert!(prev.is_none());
-        self
-    }
-    pub fn with_query(
-        mut self,
-        query_type: QueryTypeId,
-        query_fn: QueryFn<T, D>,
-    ) -> Self {
-        let prev = self.query_fn.insert(query_type, query_fn);
-        assert!(prev.is_none());
-        self
-    }
-}
-
-pub struct QueryCtx<T, D> {
-    db: Arc<DbState<T, D>>,
-    query_config: Arc<QueryConfig<T, D>>,
-    stack: RefCell<Vec<Vec<(QueryId, OutputFingerprint)>>>,
-    executed: RefCell<Vec<QueryTypeId>>,
-}
-
-impl<T, D> QueryCtx<T, D>
-where
-    D: Clone
-{
-    fn new(db: &Db<T, D>) -> QueryCtx<T, D> {
-        QueryCtx {
-            db: Arc::clone(&db.db),
-            query_config: Arc::clone(&db.query_config),
-            stack: RefCell::new(vec![Vec::new()]),
-            executed: RefCell::new(Vec::new()),
-        }
-    }
-    pub fn get(
-        &self,
-        query_id: QueryId,
-        params: D,
-    ) -> D {
-        let (res, output_fingerprint) = self.get_inner(query_id, params);
-        self.record_dep(query_id, output_fingerprint);
-        res
-    }
-    pub fn trace(&self) -> Vec<QueryTypeId> {
-        ::std::mem::replace(&mut *self.executed.borrow_mut(), Vec::new())
-    }
-
-    fn get_inner(
-        &self,
-        query_id: QueryId,
-        params: D,
-    ) -> (D, OutputFingerprint) {
-        let (gen, record) = {
-            let guard = self.db.graph.lock();
-            match guard.get(&query_id).map(|it| it.clone()){
-                None => {
-                    drop(guard);
-                    return self.force(query_id, params);
-                },
-                Some(it) => it,
-            }
-        };
-        if gen == self.db.gen {
-            return (record.output.clone(), record.output_fingerprint)
-        }
-        if self.query_config.ground_fn.contains_key(&query_id.0) {
-            let (invalidated, record) = {
-                let guard = self.db.graph.lock();
-                let (gen, ref record) = guard[&query_id];
-                (gen == INVALIDATED, record.clone())
-            };
-            if invalidated {
-                return self.force(query_id, params);
-            } else {
-                return (record.output.clone(), record.output_fingerprint);
-            }
-        }
-        for (dep_query_id, prev_fingerprint) in record.deps.iter().cloned() {
-            let dep_params: D = {
-                let guard = self.db.graph.lock();
-                guard[&dep_query_id]
-                .1
-                .params
-                .clone()
-            };
-            if prev_fingerprint != self.get_inner(dep_query_id, dep_params).1 {
-                return self.force(query_id, params)
-            }
-        }
-        let gen = self.db.gen;
-        {
-            let mut guard = self.db.graph.lock();
-            guard[&query_id].0 = gen;
-        }
-        (record.output.clone(), record.output_fingerprint)
-    }
-    fn force(
-        &self,
-        query_id: QueryId,
-        params: D,
-    ) -> (D, OutputFingerprint) {
-        self.executed.borrow_mut().push(query_id.0);
-        self.stack.borrow_mut().push(Vec::new());
-
-        let (res, output_fingerprint) = if let Some(f) = self.query_config.ground_fn.get(&query_id.0) {
-            f(&self.db.ground_data, &params)
-        } else if let Some(f) = self.query_config.query_fn.get(&query_id.0) {
-            f(self, &params)
-        } else {
-            panic!("unknown query type: {:?}", query_id.0);
-        };
-
-        let res: D = res.into();
-
-        let deps = self.stack.borrow_mut().pop().unwrap();
-        self.db.record(query_id, params, res.clone(), output_fingerprint, deps);
-        (res, output_fingerprint)
-    }
-    fn record_dep(
-        &self,
-        query_id: QueryId,
-        output_fingerprint: OutputFingerprint,
-    ) -> () {
-        let mut stack = self.stack.borrow_mut();
-        let deps = stack.last_mut().unwrap();
-        deps.push((query_id, output_fingerprint))
-    }
-}
-
-pub struct Invalidations {
-    types: HashSet<QueryTypeId>,
-    ids: Vec<QueryId>,
-}
-
-impl Invalidations {
-    pub fn new() -> Invalidations {
-        Invalidations {
-            types: HashSet::new(),
-            ids: Vec::new(),
-        }
-    }
-    pub fn invalidate(
-        &mut self,
-        query_type: QueryTypeId,
-        params: impl Iterator<Item=InputFingerprint>,
-    ) {
-        self.types.insert(query_type);
-        self.ids.extend(params.map(|it| QueryId(query_type, it)))
-    }
-}
-
-impl<T, D> Db<T, D>
-where
-    D: Clone
-{
-    pub fn new(query_config: QueryConfig<T, D>, ground_data: T) -> Db<T, D> {
-        Db {
-            db: Arc::new(DbState { ground_data, gen: Gen(0), graph: Default::default() }),
-            query_config: Arc::new(query_config),
-        }
-    }
-    pub fn ground_data(&self) -> &T {
-        &self.db.ground_data
-    }
-    pub fn with_ground_data(
-        &self,
-        ground_data: T,
-        invalidations: Invalidations,
-    ) -> Db<T, D> {
-        for id in self.query_config.ground_fn.keys() {
-            assert!(
-                invalidations.types.contains(id),
-                "all ground queries must be invalidated"
-            );
-        }
-
-        let gen = Gen(self.db.gen.0 + 1);
-        let mut graph = self.db.graph.lock().clone();
-        for id in invalidations.ids {
-            if let Some((gen, _)) = graph.get_mut(&id) {
-                *gen = INVALIDATED;
-            }
-        }
-        let graph = Mutex::new(graph);
-        Db {
-            db: Arc::new(DbState { ground_data, gen, graph }),
-            query_config: Arc::clone(&self.query_config)
-        }
-    }
-    pub fn query_ctx(&self) -> QueryCtx<T, D> {
-        QueryCtx::new(self)
-    }
-    pub fn get(
-        &self,
-        query_id: QueryId,
-        params: D,
-    ) -> (D, Vec<QueryTypeId>) {
-        let ctx = self.query_ctx();
-        let res = ctx.get(query_id, params.into());
-        let executed = ::std::mem::replace(&mut *ctx.executed.borrow_mut(), Vec::new());
-        (res, executed)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-struct Gen(u64);
-const INVALIDATED: Gen = Gen(!0);
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct InputFingerprint(pub u64);
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct OutputFingerprint(pub u64);
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct QueryTypeId(pub u16);
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct QueryId(pub QueryTypeId, pub InputFingerprint);
-
diff --git a/crates/salsa/tests/integration.rs b/crates/salsa/tests/integration.rs
deleted file mode 100644
index aed9219be..000000000
--- a/crates/salsa/tests/integration.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-extern crate salsa;
-use std::{
-    iter::once,
-    sync::Arc,
-    collections::hash_map::{HashMap, DefaultHasher},
-    any::Any,
-    hash::{Hash, Hasher},
-};
-
-type State = HashMap<u32, String>;
-type Data = Arc<Any + Send + Sync + 'static>;
-const GET_TEXT: salsa::QueryTypeId = salsa::QueryTypeId(1);
-const GET_FILES: salsa::QueryTypeId = salsa::QueryTypeId(2);
-const FILE_NEWLINES: salsa::QueryTypeId = salsa::QueryTypeId(3);
-const TOTAL_NEWLINES: salsa::QueryTypeId = salsa::QueryTypeId(4);
-
-fn mk_ground_query<T, R>(
-    state: &State,
-    params: &Data,
-    f: fn(&State, &T) -> R,
-) -> (Data, salsa::OutputFingerprint)
-where
-    T: 'static,
-    R: Hash + Send + Sync + 'static,
-{
-    let params = params.downcast_ref().unwrap();
-    let result = f(state, params);
-    let fingerprint = o_print(&result);
-    (Arc::new(result), fingerprint)
-}
-
-fn get<T, R>(db: &salsa::Db<State, Data>, query_type: salsa::QueryTypeId, param: T) -> (Arc<R>, Vec<salsa::QueryTypeId>)
-where
-    T: Hash + Send + Sync + 'static,
-    R: Send + Sync + 'static,
-{
-    let i_print = i_print(&param);
-    let param = Arc::new(param);
-    let (res, trace) = db.get(salsa::QueryId(query_type, i_print), param);
-    (res.downcast().unwrap(), trace)
-}
-
-struct QueryCtx<'a>(&'a salsa::QueryCtx<State, Data>);
-
-impl<'a> QueryCtx<'a> {
-    fn get_text(&self, id: u32) -> Arc<String> {
-        let i_print = i_print(&id);
-        let text = self.0.get(salsa::QueryId(GET_TEXT, i_print), Arc::new(id));
-        text.downcast().unwrap()
-    }
-    fn get_files(&self) -> Arc<Vec<u32>> {
-        let i_print = i_print(&());
-        let files = self.0.get(salsa::QueryId(GET_FILES, i_print), Arc::new(()));
-        let res = files.downcast().unwrap();
-        res
-    }
-    fn get_n_lines(&self, id: u32) -> usize {
-        let i_print = i_print(&id);
-        let n_lines = self.0.get(salsa::QueryId(FILE_NEWLINES, i_print), Arc::new(id));
-        *n_lines.downcast().unwrap()
-    }
-}
-
-fn mk_query<T, R>(
-    query_ctx: &salsa::QueryCtx<State, Data>,
-    params: &Data,
-    f: fn(QueryCtx, &T) -> R,
-) -> (Data, salsa::OutputFingerprint)
-where
-    T: 'static,
-    R: Hash + Send + Sync + 'static,
-{
-    let params: &T = params.downcast_ref().unwrap();
-    let query_ctx = QueryCtx(query_ctx);
-    let result = f(query_ctx, params);
-    let fingerprint = o_print(&result);
-    (Arc::new(result), fingerprint)
-}
-
-fn mk_queries() -> salsa::QueryConfig<State, Data> {
-    salsa::QueryConfig::<State, Data>::new()
-        .with_ground_query(GET_TEXT, Box::new(|state, id| {
-            mk_ground_query::<u32, String>(state, id, |state, id| state[id].clone())
-        }))
-        .with_ground_query(GET_FILES, Box::new(|state, id| {
-            mk_ground_query::<(), Vec<u32>>(state, id, |state, &()| state.keys().cloned().collect())
-        }))
-        .with_query(FILE_NEWLINES, Box::new(|query_ctx, id| {
-            mk_query(query_ctx, id, |query_ctx, &id| {
-                let text = query_ctx.get_text(id);
-                text.lines().count()
-            })
-        }))
-        .with_query(TOTAL_NEWLINES, Box::new(|query_ctx, id| {
-            mk_query(query_ctx, id, |query_ctx, &()| {
-                let mut total = 0;
-                for &id in query_ctx.get_files().iter() {
-                    total += query_ctx.get_n_lines(id)
-                }
-                total
-            })
-        }))
-}
-
-#[test]
-fn test_number_of_lines() {
-    let mut state = State::new();
-    let db = salsa::Db::new(mk_queries(), state.clone());
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 0);
-    assert_eq!(trace.len(), 2);
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 0);
-    assert_eq!(trace.len(), 0);
-
-    state.insert(1, "hello\nworld".to_string());
-    let mut inv = salsa::Invalidations::new();
-    inv.invalidate(GET_TEXT, once(i_print(&1u32)));
-    inv.invalidate(GET_FILES, once(i_print(&())));
-    let db = db.with_ground_data(state.clone(), inv);
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 2);
-    assert_eq!(trace.len(), 4);
-
-    state.insert(2, "spam\neggs".to_string());
-    let mut inv = salsa::Invalidations::new();
-    inv.invalidate(GET_TEXT, once(i_print(&2u32)));
-    inv.invalidate(GET_FILES, once(i_print(&())));
-    let db = db.with_ground_data(state.clone(), inv);
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 4);
-    assert_eq!(trace.len(), 4);
-
-    let mut invs = vec![];
-    for i in 0..10 {
-        let id = i + 10;
-        invs.push(i_print(&id));
-        state.insert(id, "spam".to_string());
-    }
-    let mut inv = salsa::Invalidations::new();
-    inv.invalidate(GET_TEXT, invs.into_iter());
-    inv.invalidate(GET_FILES, once(i_print(&())));
-    let db = db.with_ground_data(state.clone(), inv);
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 14);
-    assert_eq!(trace.len(), 22);
-
-    state.insert(15, String::new());
-    let mut inv = salsa::Invalidations::new();
-    inv.invalidate(GET_TEXT, once(i_print(&15u32)));
-    inv.invalidate(GET_FILES, once(i_print(&())));
-    let db = db.with_ground_data(state.clone(), inv);
-    let (newlines, trace) = get::<(), usize>(&db, TOTAL_NEWLINES, ());
-    assert_eq!(*newlines, 13);
-    assert_eq!(trace.len(), 4);
-}
-
-fn o_print<T: Hash>(x: &T) -> salsa::OutputFingerprint {
-    let mut hasher = DefaultHasher::new();
-    x.hash(&mut hasher);
-    let hash = hasher.finish();
-    salsa::OutputFingerprint(hash)
-}
-
-fn i_print<T: Hash>(x: &T) -> salsa::InputFingerprint {
-    let mut hasher = DefaultHasher::new();
-    x.hash(&mut hasher);
-    let hash = hasher.finish();
-    salsa::InputFingerprint(hash)
-}
diff --git a/crates/test_utils/Cargo.toml b/crates/test_utils/Cargo.toml
index 41316581e..fe0998ab8 100644
--- a/crates/test_utils/Cargo.toml
+++ b/crates/test_utils/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "test_utils"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 068eb80ce..ee73153f0 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -38,22 +38,44 @@ pub fn assert_eq_dbg(expected: &str, actual: &impl fmt::Debug) {
 }
 
 pub fn extract_offset(text: &str) -> (TextUnit, String) {
-    let cursor = "<|>";
-    let cursor_pos = match text.find(cursor) {
+    match try_extract_offset(text) {
         None => panic!("text should contain cursor marker"),
-        Some(pos) => pos,
-    };
+        Some(result) => result,
+    }
+}
+
+pub fn try_extract_offset(text: &str) -> Option<(TextUnit, String)> {
+    let cursor = "<|>";
+    let cursor_pos = text.find(cursor)?;
     let mut new_text = String::with_capacity(text.len() - cursor.len());
     new_text.push_str(&text[..cursor_pos]);
     new_text.push_str(&text[cursor_pos + cursor.len()..]);
     let cursor_pos = TextUnit::from(cursor_pos as u32);
-    (cursor_pos, new_text)
+    Some((cursor_pos, new_text))
 }
 
 pub fn extract_range(text: &str) -> (TextRange, String) {
-    let (start, text) = extract_offset(text);
-    let (end, text) = extract_offset(&text);
-    (TextRange::from_to(start, end), text)
+    match try_extract_range(text) {
+        None => panic!("text should contain cursor marker"),
+        Some(result) => result,
+    }
+}
+
+pub fn try_extract_range(text: &str) -> Option<(TextRange, String)> {
+    let (start, text) = try_extract_offset(text)?;
+    let (end, text) = try_extract_offset(&text)?;
+    Some((TextRange::from_to(start, end), text))
+}
+
+pub fn extract_ranges(text: &str) -> (Vec<TextRange>, String) {
+    let mut ranges = Vec::new();
+    let mut text = String::from(text);
+    while let Some((range, new_text)) = try_extract_range(&text) {
+        text = new_text;
+        ranges.push(range);
+    }
+
+    (ranges, text)
 }
 
 pub fn add_cursor(text: &str, offset: TextUnit) -> String {
diff --git a/crates/tools/Cargo.toml b/crates/tools/Cargo.toml
index d03910986..e2fecc60d 100644
--- a/crates/tools/Cargo.toml
+++ b/crates/tools/Cargo.toml
@@ -1,4 +1,5 @@
 [package]
+edition = "2018"
 name = "tools"
 version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]