8 files changed, 170 insertions, 67 deletions

diff --git a/crates/ra_analysis/src/completion/complete_dot.rs b/crates/ra_analysis/src/completion/complete_dot.rs
index f24835d17..031d8b98f 100644
--- a/crates/ra_analysis/src/completion/complete_dot.rs
+++ b/crates/ra_analysis/src/completion/complete_dot.rs
@@ -73,6 +73,21 @@ mod tests {
     }
 
     #[test]
+    fn test_struct_field_completion_self() {
+        check_ref_completion(
+            r"
+            struct A { the_field: u32 }
+            impl A {
+                fn foo(self) {
+                    self.<|>
+                }
+            }
+            ",
+            r#"the_field"#,
+        );
+    }
+
+    #[test]
     fn test_no_struct_field_completion_for_method_call() {
         check_ref_completion(
             r"
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index d7740f0c4..5422a400b 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -105,6 +105,7 @@ salsa::database_storage! {
             fn type_for_field() for hir::db::TypeForFieldQuery;
             fn struct_data() for hir::db::StructDataQuery;
             fn enum_data() for hir::db::EnumDataQuery;
+            fn impls_in_module() for hir::db::ImplsInModuleQuery;
         }
     }
 }
diff --git a/crates/ra_analysis/src/goto_defenition.rs b/crates/ra_analysis/src/goto_defenition.rs
new file mode 100644
index 000000000..607a25115
--- /dev/null
+++ b/crates/ra_analysis/src/goto_defenition.rs
@@ -0,0 +1,73 @@
+use ra_db::FileId;
+use ra_syntax::ast;
+
+use crate::db::RootDatabase;
+
+pub fn goto_defenition(db: &RootDatabase, position: FilePosition,
+) -> Cancelable<Option<Vec<NavigationTarget>>> {
+    let file = db.source_file(position.file_id);
+    let syntax = file.syntax();
+    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+        return Ok(Some(reference_defenition(db, position.file_id, name_ref)));
+    }
+    if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset)  {
+        return Ok(Some(name_defenition(db, position.file_idname)));
+    }
+    Ok(None)
+}
+
+fn reference_defenition(db: &RootDatabase, file_id: FileId, name_ref: ast::NameRef) -> Cancelable<Vec<Nav>> {
+    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+        let mut rr = ReferenceResolution::new(name_ref.syntax().range());
+        if let Some(fn_descr) =
+            source_binder::function_from_child_node(self, position.file_id, name_ref.syntax())?
+        {
+            let scope = fn_descr.scopes(self);
+            // First try to resolve the symbol locally
+            if let Some(entry) = scope.resolve_local_name(name_ref) {
+                rr.resolves_to.push(NavigationTarget {
+                    file_id: position.file_id,
+                    name: entry.name().to_string().into(),
+                    range: entry.ptr().range(),
+                    kind: NAME,
+                    ptr: None,
+                });
+                return Ok(Some(rr));
+            };
+        }
+        // If that fails try the index based approach.
+        rr.resolves_to.extend(
+            self.index_resolve(name_ref)?
+                .into_iter()
+                .map(NavigationTarget::from_symbol),
+        );
+        return Ok(Some(rr));
+    }
+        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
+            let mut rr = ReferenceResolution::new(name.syntax().range());
+            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
+                if module.has_semi() {
+                    if let Some(child_module) =
+                        source_binder::module_from_declaration(self, position.file_id, module)?
+                    {
+                        let file_id = child_module.file_id();
+                        let name = match child_module.name() {
+                            Some(name) => name.to_string().into(),
+                            None => "".into(),
+                        };
+                        let symbol = NavigationTarget {
+                            file_id,
+                            name,
+                            range: TextRange::offset_len(0.into(), 0.into()),
+                            kind: MODULE,
+                            ptr: None,
+                        };
+                        rr.resolves_to.push(symbol);
+                        return Ok(Some(rr));
+                    }
+                }
+            }
+        }
+        Ok(None)
+
+}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index b812c3441..eae73c2c4 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -6,7 +6,7 @@ use hir::{
     self, FnSignatureInfo, Problem, source_binder,
 };
 use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
-use ra_editor::{self, find_node_at_offset, LocalEdit, Severity};
+use ra_editor::{self, find_node_at_offset, assists, LocalEdit, Severity};
 use ra_syntax::{
     algo::{find_covering_node, visit::{visitor, Visitor}},
     ast::{self, ArgListOwner, Expr, FnDef, NameOwner},
@@ -165,9 +165,11 @@ impl db::RootDatabase {
                 };
             }
             // If that fails try the index based approach.
-            for (file_id, symbol) in self.index_resolve(name_ref)? {
-                rr.add_resolution(file_id, symbol);
-            }
+            rr.resolves_to.extend(
+                self.index_resolve(name_ref)?
+                    .into_iter()
+                    .map(NavigationTarget::from_symbol),
+            );
             return Ok(Some(rr));
         }
         if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
@@ -333,19 +335,9 @@ impl db::RootDatabase {
 
     pub(crate) fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
         let file = self.source_file(frange.file_id);
-        let offset = frange.range.start();
-        let actions = vec![
-            ra_editor::flip_comma(&file, offset).map(|f| f()),
-            ra_editor::add_derive(&file, offset).map(|f| f()),
-            ra_editor::add_impl(&file, offset).map(|f| f()),
-            ra_editor::make_pub_crate(&file, offset).map(|f| f()),
-            ra_editor::introduce_variable(&file, frange.range).map(|f| f()),
-        ];
-        actions
+        assists::assists(&file, frange.range)
             .into_iter()
-            .filter_map(|local_edit| {
-                Some(SourceChange::from_local_edit(frange.file_id, local_edit?))
-            })
+            .map(|local_edit| SourceChange::from_local_edit(frange.file_id, local_edit))
             .collect()
     }
 
@@ -362,13 +354,15 @@ impl db::RootDatabase {
 
         // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
         let file_symbols = self.index_resolve(name_ref)?;
-        for (fn_file_id, fs) in file_symbols {
-            if fs.ptr.kind() == FN_DEF {
-                let fn_file = self.source_file(fn_file_id);
-                let fn_def = fs.ptr.resolve(&fn_file);
+        for symbol in file_symbols {
+            if symbol.ptr.kind() == FN_DEF {
+                let fn_file = self.source_file(symbol.file_id);
+                let fn_def = symbol.ptr.resolve(&fn_file);
                 let fn_def = ast::FnDef::cast(fn_def.borrowed()).unwrap();
                 let descr = ctry!(source_binder::function_from_source(
-                    self, fn_file_id, fn_def
+                    self,
+                    symbol.file_id,
+                    fn_def
                 )?);
                 if let Some(descriptor) = descr.signature_info(self) {
                     // If we have a calling expression let's find which argument we are on
@@ -440,7 +434,7 @@ impl db::RootDatabase {
             .map(|(file_id, text_range)| SourceFileEdit {
                 file_id: *file_id,
                 edit: {
-                    let mut builder = ra_text_edit::TextEditBuilder::new();
+                    let mut builder = ra_text_edit::TextEditBuilder::default();
                     builder.replace(*text_range, new_name.into());
                     builder.finish()
                 },
@@ -448,7 +442,7 @@ impl db::RootDatabase {
             .collect::<Vec<_>>();
         Ok(res)
     }
-    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
         query.exact();
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 61af676b2..1e26a2889 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -237,11 +237,11 @@ pub struct NavigationTarget {
 }
 
 impl NavigationTarget {
-    fn from_symbol(file_id: FileId, symbol: FileSymbol) -> NavigationTarget {
+    fn from_symbol(symbol: FileSymbol) -> NavigationTarget {
         NavigationTarget {
+            file_id: symbol.file_id,
             name: symbol.name.clone(),
             kind: symbol.ptr.kind(),
-            file_id,
             range: symbol.ptr.range(),
             ptr: Some(symbol.ptr.clone()),
         }
@@ -278,11 +278,6 @@ impl ReferenceResolution {
             resolves_to: Vec::new(),
         }
     }
-
-    fn add_resolution(&mut self, file_id: FileId, symbol: FileSymbol) {
-        self.resolves_to
-            .push(NavigationTarget::from_symbol(file_id, symbol))
-    }
 }
 
 /// `AnalysisHost` stores the current state of the world.
@@ -380,7 +375,7 @@ impl Analysis {
     pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<NavigationTarget>> {
         let res = symbol_index::world_symbols(&*self.db, query)?
             .into_iter()
-            .map(|(file_id, symbol)| NavigationTarget::from_symbol(file_id, symbol))
+            .map(NavigationTarget::from_symbol)
             .collect();
         Ok(res)
     }
@@ -399,7 +394,7 @@ impl Analysis {
     pub fn doc_text_for(&self, nav: NavigationTarget) -> Cancelable<Option<String>> {
         self.db.doc_text_for(nav)
     }
-    /// Returns a `mod name;` declaration whihc created the current module.
+    /// Returns a `mod name;` declaration which created the current module.
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
         self.db.parent_module(position)
     }
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 960529404..846c76cfe 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -4,7 +4,7 @@ use relative_path::RelativePathBuf;
 use test_utils::{extract_offset, extract_range, parse_fixture, CURSOR_MARKER};
 use ra_db::mock::FileMap;
 
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition, FileRange, SourceRootId};
+use crate::{Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, FilePosition, FileRange, SourceRootId};
 
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -87,12 +87,17 @@ impl MockAnalysis {
         let source_root = SourceRootId(0);
         let mut change = AnalysisChange::new();
         change.add_root(source_root, true);
+        let mut crate_graph = CrateGraph::default();
         for (path, contents) in self.files.into_iter() {
             assert!(path.starts_with('/'));
             let path = RelativePathBuf::from_path(&path[1..]).unwrap();
             let file_id = file_map.add(path.clone());
+            if path == "/lib.rs" || path == "/main.rs" {
+                crate_graph.add_crate_root(file_id);
+            }
             change.add_file(source_root, file_id, path, Arc::new(contents));
         }
+        change.set_crate_graph(crate_graph);
         // change.set_file_resolver(Arc::new(file_map));
         host.apply_change(change);
         host
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 10d8e8059..e2b1c88fe 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -20,6 +20,7 @@
 //! file in the current workspace, and run a query aginst the union of all
 //! thouse fsts.
 use std::{
+    cmp::Ordering,
     hash::{Hash, Hasher},
     sync::Arc,
 };
@@ -27,11 +28,11 @@ use std::{
 use fst::{self, Streamer};
 use ra_syntax::{
     SyntaxNodeRef, SourceFileNode, SmolStr,
-    algo::visit::{visitor, Visitor},
+    algo::{visit::{visitor, Visitor}, find_covering_node},
     SyntaxKind::{self, *},
     ast::{self, NameOwner},
 };
-use ra_db::{SyntaxDatabase, SourceRootId, FilesDatabase, LocalSyntaxPtr};
+use ra_db::{SourceRootId, FilesDatabase, LocalSyntaxPtr};
 use salsa::ParallelDatabase;
 use rayon::prelude::*;
 
@@ -41,7 +42,7 @@ use crate::{
 };
 
 salsa::query_group! {
-    pub(crate) trait SymbolsDatabase: SyntaxDatabase {
+    pub(crate) trait SymbolsDatabase: hir::db::HirDatabase {
         fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
             type FileSymbolsQuery;
         }
@@ -52,16 +53,26 @@ salsa::query_group! {
     }
 }
 
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
     db.check_canceled()?;
-    let syntax = db.source_file(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
+    let source_file = db.source_file(file_id);
+    let mut symbols = source_file
+        .syntax()
+        .descendants()
+        .filter_map(to_symbol)
+        .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
+        .collect::<Vec<_>>();
+
+    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id)? {
+        let node = find_covering_node(source_file.syntax(), text_range);
+        let ptr = LocalSyntaxPtr::new(node);
+        symbols.push(FileSymbol { file_id, name, ptr })
+    }
+
+    Ok(Arc::new(SymbolIndex::new(symbols)))
 }
 
-pub(crate) fn world_symbols(
-    db: &RootDatabase,
-    query: Query,
-) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Cancelable<Vec<FileSymbol>> {
     /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
     struct Snap(salsa::Snapshot<RootDatabase>);
     impl Clone for Snap {
@@ -95,7 +106,7 @@ pub(crate) fn world_symbols(
 
 #[derive(Default, Debug)]
 pub(crate) struct SymbolIndex {
-    symbols: Vec<(FileId, FileSymbol)>,
+    symbols: Vec<FileSymbol>,
     map: fst::Map,
 }
 
@@ -114,6 +125,17 @@ impl Hash for SymbolIndex {
 }
 
 impl SymbolIndex {
+    fn new(mut symbols: Vec<FileSymbol>) -> SymbolIndex {
+        fn cmp(s1: &FileSymbol, s2: &FileSymbol) -> Ordering {
+            unicase::Ascii::new(s1.name.as_str()).cmp(&unicase::Ascii::new(s2.name.as_str()))
+        }
+        symbols.par_sort_by(cmp);
+        symbols.dedup_by(|s1, s2| cmp(s1, s2) == Ordering::Equal);
+        let names = symbols.iter().map(|it| it.name.as_str().to_lowercase());
+        let map = fst::Map::from_iter(names.into_iter().zip(0u64..)).unwrap();
+        SymbolIndex { symbols, map }
+    }
+
     pub(crate) fn len(&self) -> usize {
         self.symbols.len()
     }
@@ -121,30 +143,21 @@ impl SymbolIndex {
     pub(crate) fn for_files(
         files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
     ) -> SymbolIndex {
-        let mut symbols = files
+        let symbols = files
             .flat_map(|(file_id, file)| {
                 file.syntax()
                     .descendants()
                     .filter_map(to_symbol)
-                    .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
+                    .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
                     .collect::<Vec<_>>()
             })
             .collect::<Vec<_>>();
-        symbols.par_sort_by(|s1, s2| s1.0.cmp(&s2.0));
-        symbols.dedup_by(|s1, s2| s1.0 == s2.0);
-        let (names, symbols): (Vec<String>, Vec<(FileId, FileSymbol)>) =
-            symbols.into_iter().unzip();
-        let map = fst::Map::from_iter(names.into_iter().zip(0u64..)).unwrap();
-        SymbolIndex { symbols, map }
-    }
-
-    pub(crate) fn for_file(file_id: FileId, file: SourceFileNode) -> SymbolIndex {
-        SymbolIndex::for_files(rayon::iter::once((file_id, file)))
+        SymbolIndex::new(symbols)
     }
 }
 
 impl Query {
-    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<(FileId, FileSymbol)> {
+    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<FileSymbol> {
         let mut op = fst::map::OpBuilder::new();
         for file_symbols in indices.iter() {
             let automaton = fst::automaton::Subsequence::new(&self.lowercased);
@@ -160,14 +173,14 @@ impl Query {
                 let file_symbols = &indices[indexed_value.index];
                 let idx = indexed_value.value as usize;
 
-                let (file_id, symbol) = &file_symbols.symbols[idx];
+                let symbol = &file_symbols.symbols[idx];
                 if self.only_types && !is_type(symbol.ptr.kind()) {
                     continue;
                 }
                 if self.exact && symbol.name != self.query {
                     continue;
                 }
-                res.push((*file_id, symbol.clone()));
+                res.push(symbol.clone());
             }
         }
         res
@@ -185,17 +198,16 @@ fn is_type(kind: SyntaxKind) -> bool {
 /// possible.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct FileSymbol {
+    pub(crate) file_id: FileId,
     pub(crate) name: SmolStr,
     pub(crate) ptr: LocalSyntaxPtr,
 }
 
-fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
-    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<FileSymbol> {
-        let name = node.name()?;
-        Some(FileSymbol {
-            name: name.text(),
-            ptr: LocalSyntaxPtr::new(node.syntax()),
-        })
+fn to_symbol(node: SyntaxNodeRef) -> Option<(SmolStr, LocalSyntaxPtr)> {
+    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<(SmolStr, LocalSyntaxPtr)> {
+        let name = node.name()?.text();
+        let ptr = LocalSyntaxPtr::new(node.syntax());
+        Some((name, ptr))
     }
     visitor()
         .visit(decl::<ast::FnDef>)
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
index ccea4aee3..35e153ca0 100644
--- a/crates/ra_analysis/src/syntax_highlighting.rs
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -43,6 +43,7 @@ mod tests {
             "
             fn main() {
                 ctry!({ let x = 92; x});
+                vec![{ let x = 92; x}];
             }
             ",
         );
@@ -53,10 +54,17 @@ mod tests {
                 HighlightedRange { range: [41; 46), tag: "macro" },
                 HighlightedRange { range: [49; 52), tag: "keyword" },
                 HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [82; 86), tag: "macro" },
+                HighlightedRange { range: [89; 92), tag: "keyword" },
+                HighlightedRange { range: [97; 99), tag: "literal" },
                 HighlightedRange { range: [49; 52), tag: "keyword" },
                 HighlightedRange { range: [53; 54), tag: "function" },
                 HighlightedRange { range: [57; 59), tag: "literal" },
-                HighlightedRange { range: [61; 62), tag: "text" }]"#,
+                HighlightedRange { range: [61; 62), tag: "text" },
+                HighlightedRange { range: [89; 92), tag: "keyword" },
+                HighlightedRange { range: [93; 94), tag: "function" },
+                HighlightedRange { range: [97; 99), tag: "literal" },
+                HighlightedRange { range: [101; 102), tag: "text" }]"#,
             &highlights,
         )
     }