Add recursive support in original_range

Author: edwin0cheng

crates/ra_ide/src/expand.rs

@@ -1,18 +1,41 @@
 //! Utilities to work with files, produced by macros.
 use std::iter::successors;
 
-use hir::{InFile, Origin};
+use hir::{db::AstDatabase, InFile, Origin};
 use ra_db::FileId;
 use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxToken, TextRange};
+use ra_syntax::{
+    algo::find_covering_element, ast, AstNode, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken,
+    TextRange,
+};
 
 use crate::FileRange;
 
 pub(crate) fn original_range(db: &RootDatabase, node: InFile<&SyntaxNode>) -> FileRange {
-    if let Some((range, Origin::Call)) = original_range_and_origin(db, node) {
-        return range;
+    let mut elem: InFile<SyntaxElement> = node.map(|n| n.clone().into());
+
+    while let Some((range, Origin::Call)) = original_range_and_origin(db, elem.as_ref()) {
+        let original_file = range.file_id.original_file(db);
+
+        if range.file_id == original_file.into() {
+            return FileRange { file_id: original_file, range: range.value };
+        }
+
+        // Fail to mapping up more, return the original file range instead
+        if elem.file_id == range.file_id {
+            log::error!("Fail to mapping up more for {:?}", range);
+            return FileRange { file_id: range.file_id.original_file(db), range: range.value };
+        }
+
+        if let Some(root) = db.parse_or_expand(range.file_id) {
+            let n = find_covering_element(&root, range.value);
+            elem = range.with_value(n);
+        } else {
+            break;
+        }
     }
 
+    // Fall back to whole macro call
     if let Some(expansion) = node.file_id.expansion_info(db) {
         if let Some(call_node) = expansion.call_node() {
             return FileRange {
@@ -27,14 +50,21 @@ pub(crate) fn original_range(db: &RootDatabase, node: InFile<&SyntaxNode>) -> Fi
 
 fn original_range_and_origin(
     db: &RootDatabase,
-    node: InFile<&SyntaxNode>,
-) -> Option<(FileRange, Origin)> {
-    let expansion = node.file_id.expansion_info(db)?;
+    elem: InFile<&SyntaxElement>,
+) -> Option<(InFile<TextRange>, Origin)> {
+    let expansion = elem.file_id.expansion_info(db)?;
+
+    let node = match elem.as_ref().value {
+        NodeOrToken::Node(it) => elem.with_value(it),
+        NodeOrToken::Token(tt) => {
+            let (tt, origin) = expansion.map_token_up(elem.with_value(tt))?;
+            return Some((tt.with_value(tt.value.text_range()), origin));
+        }
+    };
 
     // the input node has only one token ?
     let single = node.value.first_token()? == node.value.last_token()?;
 
-    // FIXME: We should handle recurside macro expansions
     let (range, origin) = node.value.descendants().find_map(|it| {
         let first = it.first_token()?;
         let last = it.last_token()?;
@@ -58,10 +88,7 @@ fn original_range_and_origin(
         ))
     })?;
 
-    return Some((
-        FileRange { file_id: range.file_id.original_file(db), range: range.value },
-        origin,
-    ));
+    return Some((range, origin));
 
     fn union_range(a: TextRange, b: TextRange) -> TextRange {
         let start = a.start().min(b.start());

crates/ra_ide/src/hover.rs

@@ -754,6 +754,27 @@ fn func(foo: i32) { if true { <|>foo; }; }
         assert_eq!(hover_on, "bar")
     }
 
+    #[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_non_ascii_space_doc() {
         check_hover_result(