Merge #5518

5518: Use resolved paths in SSR rules r=matklad a=davidlattimore

The main user-visible changes are:
* SSR now matches paths based on whether they resolve to the same thing instead of whether they're written the same.
  * So `foo()` won't match `foo()` if it's a different function `foo()`, but will match `bar::foo()` if it's the same `foo`.
* Paths in the replacement will now be rendered with appropriate qualification for their context.
  * For example `foo::Bar` will render as just `Bar` inside the module `foo`, but might render as `baz::foo::Bar` from elsewhere.
* This means that all paths in the search pattern and replacement template must be able to be resolved.
* It now also matters where you invoke SSR from, since paths are resolved relative to wherever that is.
* Search now uses find-uses on paths to locate places to try matching. This means that when a path is present in the pattern, search will generally be pretty fast.
* Function calls can now match method calls again, but this time only if they resolve to the same function.

Co-authored-by: David Lattimore <[email protected]>

1 files changed, 93 insertions, 35 deletions

diff --git a/crates/ra_ssr/src/replacing.rs b/crates/ra_ssr/src/replacing.rs
index e43cc5167..4b3f5509c 100644
--- a/crates/ra_ssr/src/replacing.rs
+++ b/crates/ra_ssr/src/replacing.rs
@@ -1,66 +1,124 @@
 //! Code for applying replacement templates for matches that have previously been found.
 
 use crate::matching::Var;
-use crate::parsing::PatternElement;
-use crate::{Match, SsrMatches};
-use ra_syntax::ast::AstToken;
-use ra_syntax::TextSize;
+use crate::{resolving::ResolvedRule, Match, SsrMatches};
+use ra_syntax::ast::{self, AstToken};
+use ra_syntax::{SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextSize};
 use ra_text_edit::TextEdit;
 
 /// Returns a text edit that will replace each match in `matches` with its corresponding replacement
 /// template. Placeholders in the template will have been substituted with whatever they matched to
 /// in the original code.
-pub(crate) fn matches_to_edit(matches: &SsrMatches, file_src: &str) -> TextEdit {
-    matches_to_edit_at_offset(matches, file_src, 0.into())
+pub(crate) fn matches_to_edit(
+    matches: &SsrMatches,
+    file_src: &str,
+    rules: &[ResolvedRule],
+) -> TextEdit {
+    matches_to_edit_at_offset(matches, file_src, 0.into(), rules)
 }
 
 fn matches_to_edit_at_offset(
     matches: &SsrMatches,
     file_src: &str,
     relative_start: TextSize,
+    rules: &[ResolvedRule],
 ) -> TextEdit {
     let mut edit_builder = ra_text_edit::TextEditBuilder::default();
     for m in &matches.matches {
         edit_builder.replace(
             m.range.range.checked_sub(relative_start).unwrap(),
-            render_replace(m, file_src),
+            render_replace(m, file_src, rules),
         );
     }
     edit_builder.finish()
 }
 
-fn render_replace(match_info: &Match, file_src: &str) -> String {
+struct ReplacementRenderer<'a> {
+    match_info: &'a Match,
+    file_src: &'a str,
+    rules: &'a [ResolvedRule],
+    rule: &'a ResolvedRule,
+}
+
+fn render_replace(match_info: &Match, file_src: &str, rules: &[ResolvedRule]) -> String {
     let mut out = String::new();
-    for r in &match_info.template.tokens {
-        match r {
-            PatternElement::Token(t) => out.push_str(t.text.as_str()),
-            PatternElement::Placeholder(p) => {
-                if let Some(placeholder_value) =
-                    match_info.placeholder_values.get(&Var(p.ident.to_string()))
-                {
-                    let range = &placeholder_value.range.range;
-                    let mut matched_text =
-                        file_src[usize::from(range.start())..usize::from(range.end())].to_owned();
-                    let edit = matches_to_edit_at_offset(
-                        &placeholder_value.inner_matches,
-                        file_src,
-                        range.start(),
-                    );
-                    edit.apply(&mut matched_text);
-                    out.push_str(&matched_text);
-                } else {
-                    // We validated that all placeholder references were valid before we
-                    // started, so this shouldn't happen.
-                    panic!(
-                        "Internal error: replacement referenced unknown placeholder {}",
-                        p.ident
-                    );
+    let rule = &rules[match_info.rule_index];
+    let template = rule
+        .template
+        .as_ref()
+        .expect("You called MatchFinder::edits after calling MatchFinder::add_search_pattern");
+    let renderer = ReplacementRenderer { match_info, file_src, rules, rule };
+    renderer.render_node(&template.node, &mut out);
+    for comment in &match_info.ignored_comments {
+        out.push_str(&comment.syntax().to_string());
+    }
+    out
+}
+
+impl ReplacementRenderer<'_> {
+    fn render_node_children(&self, node: &SyntaxNode, out: &mut String) {
+        for node_or_token in node.children_with_tokens() {
+            self.render_node_or_token(&node_or_token, out);
+        }
+    }
+
+    fn render_node_or_token(&self, node_or_token: &SyntaxElement, out: &mut String) {
+        match node_or_token {
+            SyntaxElement::Token(token) => {
+                self.render_token(&token, out);
+            }
+            SyntaxElement::Node(child_node) => {
+                self.render_node(&child_node, out);
+            }
+        }
+    }
+
+    fn render_node(&self, node: &SyntaxNode, out: &mut String) {
+        use ra_syntax::ast::AstNode;
+        if let Some(mod_path) = self.match_info.rendered_template_paths.get(&node) {
+            out.push_str(&mod_path.to_string());
+            // Emit everything except for the segment's name-ref, since we already effectively
+            // emitted that as part of `mod_path`.
+            if let Some(path) = ast::Path::cast(node.clone()) {
+                if let Some(segment) = path.segment() {
+                    for node_or_token in segment.syntax().children_with_tokens() {
+                        if node_or_token.kind() != SyntaxKind::NAME_REF {
+                            self.render_node_or_token(&node_or_token, out);
+                        }
+                    }
                 }
             }
+        } else {
+            self.render_node_children(&node, out);
         }
     }
-    for comment in &match_info.ignored_comments {
-        out.push_str(&comment.syntax().to_string());
+
+    fn render_token(&self, token: &SyntaxToken, out: &mut String) {
+        if let Some(placeholder) = self.rule.get_placeholder(&token) {
+            if let Some(placeholder_value) =
+                self.match_info.placeholder_values.get(&Var(placeholder.ident.to_string()))
+            {
+                let range = &placeholder_value.range.range;
+                let mut matched_text =
+                    self.file_src[usize::from(range.start())..usize::from(range.end())].to_owned();
+                let edit = matches_to_edit_at_offset(
+                    &placeholder_value.inner_matches,
+                    self.file_src,
+                    range.start(),
+                    self.rules,
+                );
+                edit.apply(&mut matched_text);
+                out.push_str(&matched_text);
+            } else {
+                // We validated that all placeholder references were valid before we
+                // started, so this shouldn't happen.
+                panic!(
+                    "Internal error: replacement referenced unknown placeholder {}",
+                    placeholder.ident
+                );
+            }
+        } else {
+            out.push_str(token.text().as_str());
+        }
     }
-    out
 }