Merge branch 'master' into feature/themes

4 files changed, 80 insertions, 25 deletions

diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 5cea805ec..3483a7176 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,6 +1,6 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{FromSource, Module, ModuleSource, PathResolution, Source, SourceAnalyzer};
+use hir::{FromSource, InFile, Module, ModuleSource, PathResolution, SourceAnalyzer};
 use ra_prof::profile;
 use ra_syntax::{ast, match_ast, AstNode};
 use test_utils::tested_by;
@@ -11,7 +11,7 @@ use super::{
 };
 use crate::db::RootDatabase;
 
-pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Option<NameDefinition> {
+pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Option<NameDefinition> {
     let _p = profile("classify_name");
     let parent = name.value.syntax().parent()?;
 
@@ -110,6 +110,15 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
                     kind: NameKind::Macro(def),
                 })
             },
+            ast::TypeParam(it) => {
+                let src = name.with_value(it);
+                let def = hir::TypeParam::from_source(db, src)?;
+                Some(NameDefinition {
+                    visibility: None,
+                    container: def.module(db),
+                    kind: NameKind::TypeParam(def),
+                })
+            },
             _ => None,
         }
     }
@@ -117,7 +126,7 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
 
 pub(crate) fn classify_name_ref(
     db: &RootDatabase,
-    name_ref: Source<&ast::NameRef>,
+    name_ref: InFile<&ast::NameRef>,
 ) -> Option<NameDefinition> {
     let _p = profile("classify_name_ref");
 
@@ -125,21 +134,22 @@ pub(crate) fn classify_name_ref(
     let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_methods);
+        tested_by!(goto_def_for_methods);
         if let Some(func) = analyzer.resolve_method_call(&method_call) {
             return Some(from_assoc_item(db, func.into()));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_fields);
+        tested_by!(goto_def_for_fields);
         if let Some(field) = analyzer.resolve_field(&field_expr) {
             return Some(from_struct_field(db, field));
         }
     }
 
     if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_record_fields);
+        tested_by!(goto_def_for_record_fields);
+        tested_by!(goto_def_for_field_init_shorthand);
         if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
             return Some(from_struct_field(db, field_def));
         }
@@ -151,7 +161,7 @@ pub(crate) fn classify_name_ref(
     let visibility = None;
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
-        tested_by!(goto_definition_works_for_macros);
+        tested_by!(goto_def_for_macros);
         if let Some(macro_def) = analyzer.resolve_macro_call(db, name_ref.with_value(&macro_call)) {
             let kind = NameKind::Macro(macro_def);
             return Some(NameDefinition { kind, container, visibility });
@@ -168,9 +178,8 @@ pub(crate) fn classify_name_ref(
             let kind = NameKind::Local(local);
             Some(NameDefinition { kind, container, visibility: None })
         }
-        PathResolution::GenericParam(par) => {
-            // FIXME: get generic param def
-            let kind = NameKind::GenericParam(par);
+        PathResolution::TypeParam(par) => {
+            let kind = NameKind::TypeParam(par);
             Some(NameDefinition { kind, container, visibility })
         }
         PathResolution::Macro(def) => {
diff --git a/crates/ra_ide/src/references/name_definition.rs b/crates/ra_ide/src/references/name_definition.rs
index 10d3a2364..8c67c8863 100644
--- a/crates/ra_ide/src/references/name_definition.rs
+++ b/crates/ra_ide/src/references/name_definition.rs
@@ -4,8 +4,8 @@
 //! Note that the reference search is possible for not all of the classified items.
 
 use hir::{
-    Adt, AssocItem, GenericParam, HasSource, ImplBlock, Local, MacroDef, Module, ModuleDef,
-    StructField, VariantDef,
+    Adt, AssocItem, HasSource, ImplBlock, Local, MacroDef, Module, ModuleDef, StructField,
+    TypeParam, VariantDef,
 };
 use ra_syntax::{ast, ast::VisibilityOwner};
 
@@ -19,7 +19,7 @@ pub enum NameKind {
     Def(ModuleDef),
     SelfType(ImplBlock),
     Local(Local),
-    GenericParam(GenericParam),
+    TypeParam(TypeParam),
 }
 
 #[derive(PartialEq, Eq)]
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index d58496049..b804d5f6d 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -2,7 +2,7 @@
 
 use hir::ModuleSource;
 use ra_db::{RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt};
-use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode};
+use ra_syntax::{algo::find_node_at_offset, ast, tokenize, AstNode, SyntaxKind, SyntaxNode};
 use ra_text_edit::TextEdit;
 
 use crate::{
@@ -17,6 +17,13 @@ pub(crate) fn rename(
     position: FilePosition,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
+    let tokens = tokenize(new_name);
+    if tokens.len() != 1
+        || (tokens[0].kind != SyntaxKind::IDENT && tokens[0].kind != SyntaxKind::UNDERSCORE)
+    {
+        return None;
+    }
+
     let parse = db.parse(position.file_id);
     if let Some((ast_name, ast_module)) =
         find_name_and_module_at_offset(parse.tree().syntax(), position)
@@ -55,7 +62,7 @@ fn rename_mod(
 ) -> Option<SourceChange> {
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
-    let module_src = hir::Source { file_id: position.file_id.into(), value: ast_module.clone() };
+    let module_src = hir::InFile { file_id: position.file_id.into(), value: ast_module.clone() };
     if let Some(module) = hir::Module::from_declaration(db, module_src) {
         let src = module.definition_source(db);
         let file_id = src.file_id.original_file(db);
@@ -124,6 +131,49 @@ mod tests {
     };
 
     #[test]
+    fn test_rename_to_underscore() {
+        test_rename(
+            r#"
+    fn main() {
+        let i<|> = 1;
+    }"#,
+            "_",
+            r#"
+    fn main() {
+        let _ = 1;
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_to_raw_identifier() {
+        test_rename(
+            r#"
+    fn main() {
+        let i<|> = 1;
+    }"#,
+            "r#fn",
+            r#"
+    fn main() {
+        let r#fn = 1;
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_to_invalid_identifier() {
+        let (analysis, position) = single_file_with_position(
+            "
+    fn main() {
+        let i<|> = 1;
+    }",
+        );
+        let new_name = "invalid!";
+        let source_change = analysis.rename(position, new_name).unwrap();
+        assert!(source_change.is_none());
+    }
+
+    #[test]
     fn test_rename_for_local() {
         test_rename(
             r#"
diff --git a/crates/ra_ide/src/references/search_scope.rs b/crates/ra_ide/src/references/search_scope.rs
index f5c9589f4..241dd358f 100644
--- a/crates/ra_ide/src/references/search_scope.rs
+++ b/crates/ra_ide/src/references/search_scope.rs
@@ -5,7 +5,7 @@
 use std::mem;
 
 use hir::{DefWithBody, HasSource, ModuleSource};
-use ra_db::{FileId, SourceDatabase, SourceDatabaseExt};
+use ra_db::{FileId, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{AstNode, TextRange};
 use rustc_hash::FxHashMap;
@@ -120,15 +120,11 @@ impl NameDefinition {
             }
             if vis.as_str() == "pub" {
                 let krate = self.container.krate();
-                let crate_graph = db.crate_graph();
-                for crate_id in crate_graph.iter() {
-                    let mut crate_deps = crate_graph.dependencies(crate_id);
-                    if crate_deps.any(|dep| dep.crate_id() == krate.crate_id()) {
-                        let root_file = crate_graph.crate_root(crate_id);
-                        let source_root_id = db.file_source_root(root_file);
-                        let source_root = db.source_root(source_root_id);
-                        res.extend(source_root.walk().map(|id| (id, None)));
-                    }
+                for rev_dep in krate.reverse_dependencies(db) {
+                    let root_file = rev_dep.root_file(db);
+                    let source_root_id = db.file_source_root(root_file);
+                    let source_root = db.source_root(source_root_id);
+                    res.extend(source_root.walk().map(|id| (id, None)));
                 }
                 return SearchScope::new(res);
             }