1 files changed, 181 insertions, 24 deletions

diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index e3ecde50d..5a3ec4eb9 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -18,7 +18,10 @@ use hir::InFile;
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
-use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode, TextUnit};
+use ra_syntax::{
+    algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextUnit,
+    TokenAtOffset,
+};
 
 use crate::{
     db::RootDatabase, display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo,
@@ -35,7 +38,20 @@ pub use self::search_scope::SearchScope;
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
     declaration: NavigationTarget,
-    references: Vec<FileRange>,
+    declaration_kind: ReferenceKind,
+    references: Vec<Reference>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Reference {
+    pub file_range: FileRange,
+    pub kind: ReferenceKind,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ReferenceKind {
+    StructLiteral,
+    Other,
 }
 
 impl ReferenceSearchResult {
@@ -43,7 +59,7 @@ impl ReferenceSearchResult {
         &self.declaration
     }
 
-    pub fn references(&self) -> &[FileRange] {
+    pub fn references(&self) -> &[Reference] {
         &self.references
     }
 
@@ -58,12 +74,18 @@ impl ReferenceSearchResult {
 // allow turning ReferenceSearchResult into an iterator
 // over FileRanges
 impl IntoIterator for ReferenceSearchResult {
-    type Item = FileRange;
-    type IntoIter = std::vec::IntoIter<FileRange>;
+    type Item = Reference;
+    type IntoIter = std::vec::IntoIter<Reference>;
 
     fn into_iter(mut self) -> Self::IntoIter {
         let mut v = Vec::with_capacity(self.len());
-        v.push(FileRange { file_id: self.declaration.file_id(), range: self.declaration.range() });
+        v.push(Reference {
+            file_range: FileRange {
+                file_id: self.declaration.file_id(),
+                range: self.declaration.range(),
+            },
+            kind: self.declaration_kind,
+        });
         v.append(&mut self.references);
         v.into_iter()
     }
@@ -71,11 +93,24 @@ impl IntoIterator for ReferenceSearchResult {
 
 pub(crate) fn find_all_refs(
     db: &RootDatabase,
-    position: FilePosition,
+    mut position: FilePosition,
     search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
+
+    let token = syntax.token_at_offset(position.offset);
+    let mut search_kind = ReferenceKind::Other;
+
+    if let TokenAtOffset::Between(ref left, ref right) = token {
+        if (right.kind() == SyntaxKind::L_CURLY || right.kind() == SyntaxKind::L_PAREN)
+            && left.kind() != SyntaxKind::IDENT
+        {
+            position = FilePosition { offset: left.text_range().start(), ..position };
+            search_kind = ReferenceKind::StructLiteral;
+        }
+    }
+
     let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
 
     let declaration = match def.kind {
@@ -96,9 +131,15 @@ pub(crate) fn find_all_refs(
         }
     };
 
-    let references = process_definition(db, def, name, search_scope);
+    let references = process_definition(db, def, name, search_scope)
+        .into_iter()
+        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
+        .collect();
 
-    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
+    Some(RangeInfo::new(
+        range,
+        ReferenceSearchResult { declaration, references, declaration_kind: ReferenceKind::Other },
+    ))
 }
 
 fn find_name<'a>(
@@ -122,7 +163,7 @@ fn process_definition(
     def: NameDefinition,
     name: String,
     scope: SearchScope,
-) -> Vec<FileRange> {
+) -> Vec<Reference> {
     let _p = profile("process_definition");
 
     let pat = name.as_str();
@@ -146,7 +187,21 @@ fn process_definition(
                 }
                 if let Some(d) = classify_name_ref(db, InFile::new(file_id.into(), &name_ref)) {
                     if d == def {
-                        refs.push(FileRange { file_id, range });
+                        let kind = if name_ref
+                            .syntax()
+                            .ancestors()
+                            .find_map(ast::RecordLit::cast)
+                            .and_then(|l| l.path())
+                            .and_then(|p| p.segment())
+                            .and_then(|p| p.name_ref())
+                            .map(|n| n == name_ref)
+                            .unwrap_or(false)
+                        {
+                            ReferenceKind::StructLiteral
+                        } else {
+                            ReferenceKind::Other
+                        };
+                        refs.push(Reference { file_range: FileRange { file_id, range }, kind });
                     }
                 }
             }
@@ -159,10 +214,33 @@ fn process_definition(
 mod tests {
     use crate::{
         mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
-        ReferenceSearchResult, SearchScope,
+        Reference, ReferenceKind, ReferenceSearchResult, SearchScope,
     };
 
     #[test]
+    fn test_struct_literal() {
+        let code = r#"
+    struct Foo <|>{
+        a: i32,
+    }
+    impl Foo {
+        fn f() -> i32 { 42 }
+    }    
+    fn main() {
+        let f: Foo;
+        f = Foo {a: Foo::f()};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15)",
+            ReferenceKind::Other,
+            &["FileId(1) [142; 145) StructLiteral"],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_for_local() {
         let code = r#"
     fn main() {
@@ -178,7 +256,17 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 5);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [33; 34)",
+            ReferenceKind::Other,
+            &[
+                "FileId(1) [67; 68) Other",
+                "FileId(1) [71; 72) Other",
+                "FileId(1) [101; 102) Other",
+                "FileId(1) [127; 128) Other",
+            ],
+        );
     }
 
     #[test]
@@ -189,7 +277,12 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13)",
+            ReferenceKind::Other,
+            &["FileId(1) [38; 39) Other"],
+        );
     }
 
     #[test]
@@ -200,7 +293,12 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13)",
+            ReferenceKind::Other,
+            &["FileId(1) [38; 39) Other"],
+        );
     }
 
     #[test]
@@ -217,7 +315,12 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "spam RECORD_FIELD_DEF FileId(1) [66; 79) [70; 74)",
+            ReferenceKind::Other,
+            &["FileId(1) [152; 156) Other"],
+        );
     }
 
     #[test]
@@ -231,7 +334,7 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
+        check_result(refs, "f FN_DEF FileId(1) [88; 104) [91; 92)", ReferenceKind::Other, &[]);
     }
 
     #[test]
@@ -246,7 +349,7 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
+        check_result(refs, "B ENUM_VARIANT FileId(1) [83; 84) [83; 84)", ReferenceKind::Other, &[]);
     }
 
     #[test]
@@ -285,7 +388,12 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(2) [16; 50) [27; 30)",
+            ReferenceKind::Other,
+            &["FileId(1) [52; 55) StructLiteral", "FileId(3) [77; 80) StructLiteral"],
+        );
     }
 
     // `mod foo;` is not in the results because `foo` is an `ast::Name`.
@@ -311,7 +419,12 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "foo SOURCE_FILE FileId(2) [0; 35)",
+            ReferenceKind::Other,
+            &["FileId(1) [13; 16) Other"],
+        );
     }
 
     #[test]
@@ -336,7 +449,12 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(3) [0; 41) [18; 21)",
+            ReferenceKind::Other,
+            &["FileId(2) [20; 23) Other", "FileId(2) [46; 49) StructLiteral"],
+        );
     }
 
     #[test]
@@ -360,11 +478,21 @@ mod tests {
         let analysis = mock.analysis();
 
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "quux FN_DEF FileId(1) [18; 34) [25; 29)",
+            ReferenceKind::Other,
+            &["FileId(2) [16; 20) Other", "FileId(3) [16; 20) Other"],
+        );
 
         let refs =
             analysis.find_all_refs(pos, Some(SearchScope::single_file(bar))).unwrap().unwrap();
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "quux FN_DEF FileId(1) [18; 34) [25; 29)",
+            ReferenceKind::Other,
+            &["FileId(3) [16; 20) Other"],
+        );
     }
 
     #[test]
@@ -379,11 +507,40 @@ mod tests {
         }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "m1 MACRO_CALL FileId(1) [9; 63) [46; 48)",
+            ReferenceKind::Other,
+            &["FileId(1) [96; 98) Other", "FileId(1) [114; 116) Other"],
+        );
     }
 
     fn get_all_refs(text: &str) -> ReferenceSearchResult {
         let (analysis, position) = single_file_with_position(text);
         analysis.find_all_refs(position, None).unwrap().unwrap()
     }
+
+    fn check_result(
+        res: ReferenceSearchResult,
+        expected_decl: &str,
+        decl_kind: ReferenceKind,
+        expected_refs: &[&str],
+    ) {
+        res.declaration().assert_match(expected_decl);
+        assert_eq!(res.declaration_kind, decl_kind);
+
+        assert_eq!(res.references.len(), expected_refs.len());
+        res.references().iter().enumerate().for_each(|(i, r)| r.assert_match(expected_refs[i]));
+    }
+
+    impl Reference {
+        fn debug_render(&self) -> String {
+            format!("{:?} {:?} {:?}", self.file_range.file_id, self.file_range.range, self.kind)
+        }
+
+        fn assert_match(&self, expected: &str) {
+            let actual = self.debug_render();
+            test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
+        }
+    }
 }