1 files changed, 123 insertions, 110 deletions

diff --git a/crates/ra_ssr/src/lib.rs b/crates/ra_ssr/src/lib.rs
index cca4576ce..2fb326b45 100644
--- a/crates/ra_ssr/src/lib.rs
+++ b/crates/ra_ssr/src/lib.rs
@@ -4,44 +4,41 @@
 //! based on a template.
 
 mod matching;
+mod nester;
 mod parsing;
 mod replacing;
+mod resolving;
+mod search;
 #[macro_use]
 mod errors;
 #[cfg(test)]
 mod tests;
 
+use crate::errors::bail;
 pub use crate::errors::SsrError;
 pub use crate::matching::Match;
-use crate::matching::{record_match_fails_reasons_scope, MatchFailureReason};
+use crate::matching::MatchFailureReason;
 use hir::Semantics;
-use ra_db::{FileId, FileRange};
-use ra_syntax::{ast, AstNode, SmolStr, SyntaxKind, SyntaxNode, TextRange};
-use ra_text_edit::TextEdit;
+use ra_db::{FileId, FilePosition, FileRange};
+use ra_ide_db::source_change::SourceFileEdit;
+use ra_syntax::{ast, AstNode, SyntaxNode, TextRange};
+use resolving::ResolvedRule;
 use rustc_hash::FxHashMap;
 
 // A structured search replace rule. Create by calling `parse` on a str.
 #[derive(Debug)]
 pub struct SsrRule {
     /// A structured pattern that we're searching for.
-    pattern: SsrPattern,
+    pattern: parsing::RawPattern,
     /// What we'll replace it with.
-    template: parsing::SsrTemplate,
+    template: parsing::RawPattern,
+    parsed_rules: Vec<parsing::ParsedRule>,
 }
 
 #[derive(Debug)]
 pub struct SsrPattern {
-    raw: parsing::RawSearchPattern,
-    /// Placeholders keyed by the stand-in ident that we use in Rust source code.
-    placeholders_by_stand_in: FxHashMap<SmolStr, parsing::Placeholder>,
-    // We store our search pattern, parsed as each different kind of thing we can look for. As we
-    // traverse the AST, we get the appropriate one of these for the type of node we're on. For many
-    // search patterns, only some of these will be present.
-    expr: Option<SyntaxNode>,
-    type_ref: Option<SyntaxNode>,
-    item: Option<SyntaxNode>,
-    path: Option<SyntaxNode>,
-    pattern: Option<SyntaxNode>,
+    raw: parsing::RawPattern,
+    parsed_rules: Vec<parsing::ParsedRule>,
 }
 
 #[derive(Debug, Default)]
@@ -53,40 +50,112 @@ pub struct SsrMatches {
 pub struct MatchFinder<'db> {
     /// Our source of information about the user's code.
     sema: Semantics<'db, ra_ide_db::RootDatabase>,
-    rules: Vec<SsrRule>,
+    rules: Vec<ResolvedRule>,
+    scope: hir::SemanticsScope<'db>,
+    hygiene: hir::Hygiene,
 }
 
 impl<'db> MatchFinder<'db> {
-    pub fn new(db: &'db ra_ide_db::RootDatabase) -> MatchFinder<'db> {
-        MatchFinder { sema: Semantics::new(db), rules: Vec::new() }
+    /// Constructs a new instance where names will be looked up as if they appeared at
+    /// `lookup_context`.
+    pub fn in_context(
+        db: &'db ra_ide_db::RootDatabase,
+        lookup_context: FilePosition,
+    ) -> MatchFinder<'db> {
+        let sema = Semantics::new(db);
+        let file = sema.parse(lookup_context.file_id);
+        // Find a node at the requested position, falling back to the whole file.
+        let node = file
+            .syntax()
+            .token_at_offset(lookup_context.offset)
+            .left_biased()
+            .map(|token| token.parent())
+            .unwrap_or_else(|| file.syntax().clone());
+        let scope = sema.scope(&node);
+        MatchFinder {
+            sema: Semantics::new(db),
+            rules: Vec::new(),
+            scope,
+            hygiene: hir::Hygiene::new(db, lookup_context.file_id.into()),
+        }
     }
 
-    pub fn add_rule(&mut self, rule: SsrRule) {
-        self.rules.push(rule);
+    /// Constructs an instance using the start of the first file in `db` as the lookup context.
+    pub fn at_first_file(db: &'db ra_ide_db::RootDatabase) -> Result<MatchFinder<'db>, SsrError> {
+        use ra_db::SourceDatabaseExt;
+        use ra_ide_db::symbol_index::SymbolsDatabase;
+        if let Some(first_file_id) = db
+            .local_roots()
+            .iter()
+            .next()
+            .and_then(|root| db.source_root(root.clone()).iter().next())
+        {
+            Ok(MatchFinder::in_context(
+                db,
+                FilePosition { file_id: first_file_id, offset: 0.into() },
+            ))
+        } else {
+            bail!("No files to search");
+        }
     }
 
-    /// Adds a search pattern. For use if you intend to only call `find_matches_in_file`. If you
-    /// intend to do replacement, use `add_rule` instead.
-    pub fn add_search_pattern(&mut self, pattern: SsrPattern) {
-        self.add_rule(SsrRule { pattern, template: "()".parse().unwrap() })
+    /// Adds a rule to be applied. The order in which rules are added matters. Earlier rules take
+    /// precedence. If a node is matched by an earlier rule, then later rules won't be permitted to
+    /// match to it.
+    pub fn add_rule(&mut self, rule: SsrRule) -> Result<(), SsrError> {
+        for parsed_rule in rule.parsed_rules {
+            self.rules.push(ResolvedRule::new(
+                parsed_rule,
+                &self.scope,
+                &self.hygiene,
+                self.rules.len(),
+            )?);
+        }
+        Ok(())
     }
 
-    pub fn edits_for_file(&self, file_id: FileId) -> Option<TextEdit> {
-        let matches = self.find_matches_in_file(file_id);
-        if matches.matches.is_empty() {
-            None
-        } else {
-            use ra_db::SourceDatabaseExt;
-            Some(replacing::matches_to_edit(&matches, &self.sema.db.file_text(file_id)))
+    /// Finds matches for all added rules and returns edits for all found matches.
+    pub fn edits(&self) -> Vec<SourceFileEdit> {
+        use ra_db::SourceDatabaseExt;
+        let mut matches_by_file = FxHashMap::default();
+        for m in self.matches().matches {
+            matches_by_file
+                .entry(m.range.file_id)
+                .or_insert_with(|| SsrMatches::default())
+                .matches
+                .push(m);
+        }
+        let mut edits = vec![];
+        for (file_id, matches) in matches_by_file {
+            let edit =
+                replacing::matches_to_edit(&matches, &self.sema.db.file_text(file_id), &self.rules);
+            edits.push(SourceFileEdit { file_id, edit });
         }
+        edits
     }
 
-    pub fn find_matches_in_file(&self, file_id: FileId) -> SsrMatches {
-        let file = self.sema.parse(file_id);
-        let code = file.syntax();
-        let mut matches = SsrMatches::default();
-        self.find_matches(code, &None, &mut matches);
-        matches
+    /// Adds a search pattern. For use if you intend to only call `find_matches_in_file`. If you
+    /// intend to do replacement, use `add_rule` instead.
+    pub fn add_search_pattern(&mut self, pattern: SsrPattern) -> Result<(), SsrError> {
+        for parsed_rule in pattern.parsed_rules {
+            self.rules.push(ResolvedRule::new(
+                parsed_rule,
+                &self.scope,
+                &self.hygiene,
+                self.rules.len(),
+            )?);
+        }
+        Ok(())
+    }
+
+    /// Returns matches for all added rules.
+    pub fn matches(&self) -> SsrMatches {
+        let mut matches = Vec::new();
+        let mut usage_cache = search::UsageCache::default();
+        for rule in &self.rules {
+            self.find_matches_for_rule(rule, &mut usage_cache, &mut matches);
+        }
+        nester::nest_and_remove_collisions(matches, &self.sema)
     }
 
     /// Finds all nodes in `file_id` whose text is exactly equal to `snippet` and attempts to match
@@ -115,53 +184,6 @@ impl<'db> MatchFinder<'db> {
         res
     }
 
-    fn find_matches(
-        &self,
-        code: &SyntaxNode,
-        restrict_range: &Option<FileRange>,
-        matches_out: &mut SsrMatches,
-    ) {
-        for rule in &self.rules {
-            if let Ok(mut m) = matching::get_match(false, rule, &code, restrict_range, &self.sema) {
-                // Continue searching in each of our placeholders.
-                for placeholder_value in m.placeholder_values.values_mut() {
-                    if let Some(placeholder_node) = &placeholder_value.node {
-                        // Don't search our placeholder if it's the entire matched node, otherwise we'd
-                        // find the same match over and over until we got a stack overflow.
-                        if placeholder_node != code {
-                            self.find_matches(
-                                placeholder_node,
-                                restrict_range,
-                                &mut placeholder_value.inner_matches,
-                            );
-                        }
-                    }
-                }
-                matches_out.matches.push(m);
-                return;
-            }
-        }
-        // If we've got a macro call, we already tried matching it pre-expansion, which is the only
-        // way to match the whole macro, now try expanding it and matching the expansion.
-        if let Some(macro_call) = ast::MacroCall::cast(code.clone()) {
-            if let Some(expanded) = self.sema.expand(&macro_call) {
-                if let Some(tt) = macro_call.token_tree() {
-                    // When matching within a macro expansion, we only want to allow matches of
-                    // nodes that originated entirely from within the token tree of the macro call.
-                    // i.e. we don't want to match something that came from the macro itself.
-                    self.find_matches(
-                        &expanded,
-                        &Some(self.sema.original_range(tt.syntax())),
-                        matches_out,
-                    );
-                }
-            }
-        }
-        for child in code.children() {
-            self.find_matches(&child, restrict_range, matches_out);
-        }
-    }
-
     fn output_debug_for_nodes_at_range(
         &self,
         node: &SyntaxNode,
@@ -177,8 +199,17 @@ impl<'db> MatchFinder<'db> {
             }
             if node_range.range == range.range {
                 for rule in &self.rules {
-                    let pattern =
-                        rule.pattern.tree_for_kind_with_reason(node.kind()).map(|p| p.clone());
+                    // For now we ignore rules that have a different kind than our node, otherwise
+                    // we get lots of noise. If at some point we add support for restricting rules
+                    // to a particular kind of thing (e.g. only match type references), then we can
+                    // relax this. We special-case expressions, since function calls can match
+                    // method calls.
+                    if rule.pattern.node.kind() != node.kind()
+                        && !(ast::Expr::can_cast(rule.pattern.node.kind())
+                            && ast::Expr::can_cast(node.kind()))
+                    {
+                        continue;
+                    }
                     out.push(MatchDebugInfo {
                         matched: matching::get_match(true, rule, &node, restrict_range, &self.sema)
                             .map_err(|e| MatchFailureReason {
@@ -186,7 +217,7 @@ impl<'db> MatchFinder<'db> {
                                     "Match failed, but no reason was given".to_owned()
                                 }),
                             }),
-                        pattern,
+                        pattern: rule.pattern.node.clone(),
                         node: node.clone(),
                     });
                 }
@@ -209,9 +240,8 @@ impl<'db> MatchFinder<'db> {
 
 pub struct MatchDebugInfo {
     node: SyntaxNode,
-    /// Our search pattern parsed as the same kind of syntax node as `node`. e.g. expression, item,
-    /// etc. Will be absent if the pattern can't be parsed as that kind.
-    pattern: Result<SyntaxNode, MatchFailureReason>,
+    /// Our search pattern parsed as an expression or item, etc
+    pattern: SyntaxNode,
     matched: Result<Match, MatchFailureReason>,
 }
 
@@ -228,29 +258,12 @@ impl std::fmt::Debug for MatchDebugInfo {
             self.node
         )?;
         writeln!(f, "========= PATTERN ==========")?;
-        match &self.pattern {
-            Ok(pattern) => {
-                writeln!(f, "{:#?}", pattern)?;
-            }
-            Err(err) => {
-                writeln!(f, "{}", err.reason)?;
-            }
-        }
+        writeln!(f, "{:#?}", self.pattern)?;
         writeln!(f, "============================")?;
         Ok(())
     }
 }
 
-impl SsrPattern {
-    fn tree_for_kind_with_reason(
-        &self,
-        kind: SyntaxKind,
-    ) -> Result<&SyntaxNode, MatchFailureReason> {
-        record_match_fails_reasons_scope(true, || self.tree_for_kind(kind))
-            .map_err(|e| MatchFailureReason { reason: e.reason.unwrap() })
-    }
-}
-
 impl SsrMatches {
     /// Returns `self` with any nested matches removed and made into top-level matches.
     pub fn flattened(self) -> SsrMatches {