1 files changed, 70 insertions, 23 deletions

diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 1c6ca36df..177038e20 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,8 +1,10 @@
 //! FIXME: write short doc here
 
-use hir::{db::AstDatabase, Adt, HasSource, HirDisplay, SourceBinder};
-use ra_db::SourceDatabase;
-use ra_ide_db::{defs::NameDefinition, RootDatabase};
+use hir::{Adt, HasSource, HirDisplay, Semantics};
+use ra_ide_db::{
+    defs::{classify_name, NameDefinition},
+    RootDatabase,
+};
 use ra_syntax::{
     algo::find_covering_element,
     ast::{self, DocCommentsOwner},
@@ -13,8 +15,7 @@ use ra_syntax::{
 
 use crate::{
     display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
-    expand::{descend_into_macros, original_range},
-    references::{classify_name, classify_name_ref},
+    references::classify_name_ref,
     FilePosition, FileRange, RangeInfo,
 };
 
@@ -143,25 +144,25 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: NameDefinition) -> Option<S
 }
 
 pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
-    let file = db.parse_or_expand(position.file_id.into())?;
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id).syntax().clone();
     let token = pick_best(file.token_at_offset(position.offset))?;
-    let token = descend_into_macros(db, position.file_id, token);
+    let token = sema.descend_into_macros(token);
 
     let mut res = HoverResult::new();
 
-    let mut sb = SourceBinder::new(db);
     if let Some((node, name_kind)) = match_ast! {
-        match (token.value.parent()) {
+        match (token.parent()) {
             ast::NameRef(name_ref) => {
-                classify_name_ref(&mut sb, token.with_value(&name_ref)).map(|d| (name_ref.syntax().clone(), d))
+                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d))
             },
             ast::Name(name) => {
-                classify_name(&mut sb, token.with_value(&name)).map(|d| (name.syntax().clone(), d))
+                classify_name(&sema, &name).map(|d| (name.syntax().clone(), d))
             },
             _ => None,
         }
     } {
-        let range = original_range(db, token.with_value(&node)).range;
+        let range = sema.original_range(&node).range;
         res.extend(hover_text_from_name_kind(db, name_kind));
 
         if !res.is_empty() {
@@ -170,11 +171,14 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
     }
 
     let node = token
-        .value
         .ancestors()
         .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
 
-    let frange = original_range(db, token.with_value(&node));
+    // FIXME: Currently `hover::typeof` do not work inside
+    // macro expansion such that if the hover range is pointing to
+    // a string literal, the following type_of will return None.
+    // See also `test_hover_through_literal_string_in_macro`
+    let frange = sema.original_range(&node);
     res.extend(type_of(db, frange).map(rust_code_markup));
     if res.is_empty() {
         return None;
@@ -197,19 +201,17 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 }
 
 pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
-    let parse = db.parse(frange.file_id);
-    let leaf_node = find_covering_element(parse.tree().syntax(), frange.range);
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(frange.file_id);
+    let leaf_node = find_covering_element(source_file.syntax(), frange.range);
     // if we picked identifier, expand to pattern/expression
     let node = leaf_node
         .ancestors()
         .take_while(|it| it.text_range() == leaf_node.text_range())
         .find(|it| ast::Expr::cast(it.clone()).is_some() || ast::Pat::cast(it.clone()).is_some())?;
-    let analyzer =
-        hir::SourceAnalyzer::new(db, hir::InFile::new(frange.file_id.into(), &node), None);
-    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
-    {
+    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| sema.type_of_expr(&e)) {
         ty
-    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, &p)) {
+    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| sema.type_of_pat(&p)) {
         ty
     } else {
         return None;
@@ -219,11 +221,12 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
 
 #[cfg(test)]
 mod tests {
+    use ra_db::FileLoader;
+    use ra_syntax::TextRange;
+
     use crate::mock_analysis::{
         analysis_and_position, single_file_with_position, single_file_with_range,
     };
-    use ra_db::FileLoader;
-    use ra_syntax::TextRange;
 
     fn trim_markup(s: &str) -> &str {
         s.trim_start_matches("```rust\n").trim_end_matches("\n```")
@@ -251,6 +254,11 @@ mod tests {
         content[hover.range].to_string()
     }
 
+    fn check_hover_no_result(fixture: &str) {
+        let (analysis, position) = analysis_and_position(fixture);
+        assert!(analysis.hover(position).unwrap().is_none());
+    }
+
     #[test]
     fn hover_shows_type_of_an_expression() {
         let (analysis, position) = single_file_with_position(
@@ -755,6 +763,45 @@ fn func(foo: i32) { if true { <|>foo; }; }
     }
 
     #[test]
+    fn test_hover_through_expr_in_macro_recursive() {
+        let hover_on = check_hover_result(
+            "
+            //- /lib.rs
+            macro_rules! id_deep {
+                ($($tt:tt)*) => { $($tt)* }
+            }
+            macro_rules! id {
+                ($($tt:tt)*) => { id_deep!($($tt)*) }
+            }
+            fn foo(bar:u32) {
+                let a = id!(ba<|>r);
+            }
+            ",
+            &["u32"],
+        );
+
+        assert_eq!(hover_on, "bar")
+    }
+
+    #[test]
+    fn test_hover_through_literal_string_in_macro() {
+        // FIXME: Currently `hover::type_of` do not work inside
+        // macro expansion
+        check_hover_no_result(
+            r#"
+            //- /lib.rs
+            macro_rules! arr {
+                ($($tt:tt)*) => { [$($tt)*)] }
+            }
+            fn foo() {
+                let mastered_for_itunes = "";
+                let _ = arr!("Tr<|>acks", &mastered_for_itunes);
+            }
+            "#,
+        );
+    }
+
+    #[test]
     fn test_hover_non_ascii_space_doc() {
         check_hover_result(
             "