Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into feature/themes

4 files changed, 42 insertions, 174 deletions

diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs
index ea9d20e71..4a4b030f8 100644
--- a/crates/ra_ide_api/src/references/classify.rs
+++ b/crates/ra_ide_api/src/references/classify.rs
@@ -13,12 +13,12 @@ use crate::db::RootDatabase;
 
 pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Option<NameDefinition> {
     let _p = profile("classify_name");
-    let parent = name.ast.syntax().parent()?;
+    let parent = name.value.syntax().parent()?;
 
     match_ast! {
         match parent {
             ast::BindPat(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let local = hir::Local::from_source(db, src)?;
                 Some(NameDefinition {
                     visibility: None,
@@ -28,7 +28,7 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
             },
             ast::RecordFieldDef(it) => {
                 let ast = hir::FieldSource::Named(it);
-                let src = name.with_ast(ast);
+                let src = name.with_value(ast);
                 let field = hir::StructField::from_source(db, src)?;
                 Some(from_struct_field(db, field))
             },
@@ -36,42 +36,42 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
                 let def = {
                     if !it.has_semi() {
                         let ast = hir::ModuleSource::Module(it);
-                        let src = name.with_ast(ast);
+                        let src = name.with_value(ast);
                         hir::Module::from_definition(db, src)
                     } else {
-                        let src = name.with_ast(it);
+                        let src = name.with_value(it);
                         hir::Module::from_declaration(db, src)
                     }
                 }?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::StructDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Struct::from_source(db, src)?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::EnumDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Enum::from_source(db, src)?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::TraitDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Trait::from_source(db, src)?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::StaticDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Static::from_source(db, src)?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::EnumVariant(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::EnumVariant::from_source(db, src)?;
                 Some(from_module_def(db, def.into(), None))
             },
             ast::FnDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Function::from_source(db, src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
                     Some(from_assoc_item(db, def.into()))
@@ -80,7 +80,7 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
                 }
             },
             ast::ConstDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::Const::from_source(db, src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
                     Some(from_assoc_item(db, def.into()))
@@ -89,7 +89,7 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
                 }
             },
             ast::TypeAliasDef(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::TypeAlias::from_source(db, src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
                     Some(from_assoc_item(db, def.into()))
@@ -98,11 +98,11 @@ pub(crate) fn classify_name(db: &RootDatabase, name: Source<&ast::Name>) -> Opti
                 }
             },
             ast::MacroCall(it) => {
-                let src = name.with_ast(it);
+                let src = name.with_value(it);
                 let def = hir::MacroDef::from_source(db, src.clone())?;
 
                 let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-                let module = Module::from_definition(db, src.with_ast(module_src))?;
+                let module = Module::from_definition(db, src.with_value(module_src))?;
 
                 Some(NameDefinition {
                     visibility: None,
@@ -121,7 +121,7 @@ pub(crate) fn classify_name_ref(
 ) -> Option<NameDefinition> {
     let _p = profile("classify_name_ref");
 
-    let parent = name_ref.ast.syntax().parent()?;
+    let parent = name_ref.value.syntax().parent()?;
     let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
@@ -142,16 +142,16 @@ pub(crate) fn classify_name_ref(
         tested_by!(goto_definition_works_for_record_fields);
         if let Some(record_lit) = record_field.syntax().ancestors().find_map(ast::RecordLit::cast) {
             let variant_def = analyzer.resolve_record_literal(&record_lit)?;
-            let hir_path = Path::from_name_ref(name_ref.ast);
+            let hir_path = Path::from_name_ref(name_ref.value);
             let hir_name = hir_path.as_ident()?;
             let field = variant_def.field(db, hir_name)?;
             return Some(from_struct_field(db, field));
         }
     }
 
-    let ast = ModuleSource::from_child_node(db, name_ref.with_ast(&parent));
+    let ast = ModuleSource::from_child_node(db, name_ref.with_value(&parent));
     // FIXME: find correct container and visibility for each case
-    let container = Module::from_definition(db, name_ref.with_ast(ast))?;
+    let container = Module::from_definition(db, name_ref.with_value(ast))?;
     let visibility = None;
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
@@ -162,7 +162,7 @@ pub(crate) fn classify_name_ref(
         }
     }
 
-    let path = name_ref.ast.syntax().ancestors().find_map(ast::Path::cast)?;
+    let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = analyzer.resolve_path(db, &path)?;
     match resolved {
         PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
diff --git a/crates/ra_ide_api/src/references/name_definition.rs b/crates/ra_ide_api/src/references/name_definition.rs
index ccd75278a..aca23f79e 100644
--- a/crates/ra_ide_api/src/references/name_definition.rs
+++ b/crates/ra_ide_api/src/references/name_definition.rs
@@ -32,9 +32,9 @@ pub(crate) struct NameDefinition {
 pub(super) fn from_assoc_item(db: &RootDatabase, item: AssocItem) -> NameDefinition {
     let container = item.module(db);
     let visibility = match item {
-        AssocItem::Function(f) => f.source(db).ast.visibility(),
-        AssocItem::Const(c) => c.source(db).ast.visibility(),
-        AssocItem::TypeAlias(a) => a.source(db).ast.visibility(),
+        AssocItem::Function(f) => f.source(db).value.visibility(),
+        AssocItem::Const(c) => c.source(db).value.visibility(),
+        AssocItem::TypeAlias(a) => a.source(db).value.visibility(),
     };
     let kind = NameKind::AssocItem(item);
     NameDefinition { kind, container, visibility }
@@ -45,8 +45,8 @@ pub(super) fn from_struct_field(db: &RootDatabase, field: StructField) -> NameDe
     let parent = field.parent_def(db);
     let container = parent.module(db);
     let visibility = match parent {
-        VariantDef::Struct(s) => s.source(db).ast.visibility(),
-        VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
+        VariantDef::Struct(s) => s.source(db).value.visibility(),
+        VariantDef::EnumVariant(e) => e.source(db).value.parent_enum().visibility(),
     };
     NameDefinition { kind, container, visibility }
 }
@@ -60,22 +60,22 @@ pub(super) fn from_module_def(
     let (container, visibility) = match def {
         ModuleDef::Module(it) => {
             let container = it.parent(db).or_else(|| Some(it)).unwrap();
-            let visibility = it.declaration_source(db).and_then(|s| s.ast.visibility());
+            let visibility = it.declaration_source(db).and_then(|s| s.value.visibility());
             (container, visibility)
         }
         ModuleDef::EnumVariant(it) => {
             let container = it.module(db);
-            let visibility = it.source(db).ast.parent_enum().visibility();
+            let visibility = it.source(db).value.parent_enum().visibility();
             (container, visibility)
         }
-        ModuleDef::Function(it) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Const(it) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Static(it) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Trait(it) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).ast.visibility()),
-        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Function(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Const(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Static(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Trait(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).value.visibility()),
         ModuleDef::BuiltinType(..) => (module.unwrap(), None),
     };
     NameDefinition { kind, container, visibility }
diff --git a/crates/ra_ide_api/src/references/rename.rs b/crates/ra_ide_api/src/references/rename.rs
index 11f81cbb3..d58496049 100644
--- a/crates/ra_ide_api/src/references/rename.rs
+++ b/crates/ra_ide_api/src/references/rename.rs
@@ -55,11 +55,11 @@ 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(), ast: ast_module.clone() };
+    let module_src = hir::Source { 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);
-        match src.ast {
+        match src.value {
             ModuleSource::SourceFile(..) => {
                 let mod_path: RelativePathBuf = db.file_relative_path(file_id);
                 // mod is defined in path/to/dir/mod.rs
@@ -121,141 +121,9 @@ mod tests {
 
     use crate::{
         mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
-        ReferenceSearchResult,
     };
 
     #[test]
-    fn test_find_all_refs_for_local() {
-        let code = r#"
-    fn main() {
-        let mut i = 1;
-        let j = 1;
-        i = i<|> + j;
-
-        {
-            i = 0;
-        }
-
-        i = 5;
-    }"#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 5);
-    }
-
-    #[test]
-    fn test_find_all_refs_for_param_inside() {
-        let code = r#"
-    fn foo(i : u32) -> u32 {
-        i<|>
-    }"#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
-    }
-
-    #[test]
-    fn test_find_all_refs_for_fn_param() {
-        let code = r#"
-    fn foo(i<|> : u32) -> u32 {
-        i
-    }"#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
-    }
-
-    #[test]
-    fn test_find_all_refs_field_name() {
-        let code = r#"
-            //- /lib.rs
-            struct Foo {
-                pub spam<|>: u32,
-            }
-
-            fn main(s: Foo) {
-                let f = s.spam;
-            }
-        "#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
-    }
-
-    #[test]
-    fn test_find_all_refs_impl_item_name() {
-        let code = r#"
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                fn f<|>(&self) {  }
-            }
-        "#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
-    }
-
-    #[test]
-    fn test_find_all_refs_enum_var_name() {
-        let code = r#"
-            //- /lib.rs
-            enum Foo {
-                A,
-                B<|>,
-                C,
-            }
-        "#;
-
-        let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
-    }
-
-    #[test]
-    fn test_find_all_refs_modules() {
-        let code = r#"
-            //- /lib.rs
-            pub mod foo;
-            pub mod bar;
-
-            fn f() {
-                let i = foo::Foo { n: 5 };
-            }
-
-            //- /foo.rs
-            use crate::bar;
-
-            pub struct Foo {
-                pub n: u32,
-            }
-
-            fn f() {
-                let i = bar::Bar { n: 5 };
-            }
-
-            //- /bar.rs
-            use crate::foo;
-
-            pub struct Bar {
-                pub n: u32,
-            }
-
-            fn f() {
-                let i = foo::Foo<|> { n: 5 };
-            }
-        "#;
-
-        let (analysis, pos) = analysis_and_position(code);
-        let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
-    }
-
-    fn get_all_refs(text: &str) -> ReferenceSearchResult {
-        let (analysis, position) = single_file_with_position(text);
-        analysis.find_all_refs(position, None).unwrap().unwrap()
-    }
-
-    #[test]
     fn test_rename_for_local() {
         test_rename(
             r#"
diff --git a/crates/ra_ide_api/src/references/search_scope.rs b/crates/ra_ide_api/src/references/search_scope.rs
index 2907787c2..f5c9589f4 100644
--- a/crates/ra_ide_api/src/references/search_scope.rs
+++ b/crates/ra_ide_api/src/references/search_scope.rs
@@ -73,9 +73,9 @@ impl NameDefinition {
 
         if let NameKind::Local(var) = self.kind {
             let range = match var.parent(db) {
-                DefWithBody::Function(f) => f.source(db).ast.syntax().text_range(),
-                DefWithBody::Const(c) => c.source(db).ast.syntax().text_range(),
-                DefWithBody::Static(s) => s.source(db).ast.syntax().text_range(),
+                DefWithBody::Function(f) => f.source(db).value.syntax().text_range(),
+                DefWithBody::Const(c) => c.source(db).value.syntax().text_range(),
+                DefWithBody::Static(s) => s.source(db).value.syntax().text_range(),
             };
             let mut res = FxHashMap::default();
             res.insert(file_id, Some(range));
@@ -91,7 +91,7 @@ impl NameDefinition {
                 let parent_src = parent_module.definition_source(db);
                 let file_id = parent_src.file_id.original_file(db);
 
-                match parent_src.ast {
+                match parent_src.value {
                     ModuleSource::Module(m) => {
                         let range = Some(m.syntax().text_range());
                         res.insert(file_id, range);
@@ -135,7 +135,7 @@ impl NameDefinition {
         }
 
         let mut res = FxHashMap::default();
-        let range = match module_src.ast {
+        let range = match module_src.value {
             ModuleSource::Module(m) => Some(m.syntax().text_range()),
             ModuleSource::SourceFile(_) => None,
         };