1 files changed, 260 insertions, 121 deletions

diff --git a/crates/ra_ssr/src/matching.rs b/crates/ra_ssr/src/matching.rs
index bb87bda43..74e15c631 100644
--- a/crates/ra_ssr/src/matching.rs
+++ b/crates/ra_ssr/src/matching.rs
@@ -2,17 +2,17 @@
 //! process of matching, placeholder values are recorded.
 
 use crate::{
-    parsing::{Placeholder, SsrTemplate},
-    SsrMatches, SsrPattern, SsrRule,
+    parsing::{Constraint, NodeKind, Placeholder},
+    resolving::{ResolvedPattern, ResolvedRule},
+    SsrMatches,
 };
 use hir::Semantics;
 use ra_db::FileRange;
 use ra_syntax::ast::{AstNode, AstToken};
-use ra_syntax::{
-    ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken, TextRange,
-};
+use ra_syntax::{ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken};
 use rustc_hash::FxHashMap;
 use std::{cell::Cell, iter::Peekable};
+use test_utils::mark;
 
 // Creates a match error. If we're currently attempting to match some code that we thought we were
 // going to match, as indicated by the --debug-snippet flag, then populate the reason field.
@@ -44,14 +44,16 @@ macro_rules! fail_match {
 
 /// Information about a match that was found.
 #[derive(Debug)]
-pub(crate) struct Match {
-    pub(crate) range: TextRange,
+pub struct Match {
+    pub(crate) range: FileRange,
     pub(crate) matched_node: SyntaxNode,
     pub(crate) placeholder_values: FxHashMap<Var, PlaceholderMatch>,
     pub(crate) ignored_comments: Vec<ast::Comment>,
-    // A copy of the template for the rule that produced this match. We store this on the match for
-    // if/when we do replacement.
-    pub(crate) template: SsrTemplate,
+    pub(crate) rule_index: usize,
+    /// The depth of matched_node.
+    pub(crate) depth: usize,
+    // Each path in the template rendered for the module in which the match was found.
+    pub(crate) rendered_template_paths: FxHashMap<SyntaxNode, hir::ModPath>,
 }
 
 /// Represents a `$var` in an SSR query.
@@ -87,64 +89,67 @@ pub(crate) struct MatchFailed {
 /// parent module, we don't populate nested matches.
 pub(crate) fn get_match(
     debug_active: bool,
-    rule: &SsrRule,
+    rule: &ResolvedRule,
     code: &SyntaxNode,
     restrict_range: &Option<FileRange>,
     sema: &Semantics<ra_ide_db::RootDatabase>,
 ) -> Result<Match, MatchFailed> {
     record_match_fails_reasons_scope(debug_active, || {
-        MatchState::try_match(rule, code, restrict_range, sema)
+        Matcher::try_match(rule, code, restrict_range, sema)
     })
 }
 
-/// Inputs to matching. This cannot be part of `MatchState`, since we mutate `MatchState` and in at
-/// least one case need to hold a borrow of a placeholder from the input pattern while calling a
-/// mutable `MatchState` method.
-struct MatchInputs<'pattern> {
-    ssr_pattern: &'pattern SsrPattern,
-}
-
-/// State used while attempting to match our search pattern against a particular node of the AST.
-struct MatchState<'db, 'sema> {
+/// Checks if our search pattern matches a particular node of the AST.
+struct Matcher<'db, 'sema> {
     sema: &'sema Semantics<'db, ra_ide_db::RootDatabase>,
     /// If any placeholders come from anywhere outside of this range, then the match will be
     /// rejected.
     restrict_range: Option<FileRange>,
-    /// The match that we're building. We do two passes for a successful match. On the first pass,
-    /// this is None so that we can avoid doing things like storing copies of what placeholders
-    /// matched to. If that pass succeeds, then we do a second pass where we collect those details.
-    /// This means that if we have a pattern like `$a.foo()` we won't do an insert into the
-    /// placeholders map for every single method call in the codebase. Instead we'll discard all the
-    /// method calls that aren't calls to `foo` on the first pass and only insert into the
-    /// placeholders map on the second pass. Likewise for ignored comments.
-    match_out: Option<Match>,
+    rule: &'sema ResolvedRule,
+}
+
+/// Which phase of matching we're currently performing. We do two phases because most attempted
+/// matches will fail and it means we can defer more expensive checks to the second phase.
+enum Phase<'a> {
+    /// On the first phase, we perform cheap checks. No state is mutated and nothing is recorded.
+    First,
+    /// On the second phase, we construct the `Match`. Things like what placeholders bind to is
+    /// recorded.
+    Second(&'a mut Match),
 }
 
-impl<'db, 'sema> MatchState<'db, 'sema> {
+impl<'db, 'sema> Matcher<'db, 'sema> {
     fn try_match(
-        rule: &SsrRule,
+        rule: &ResolvedRule,
         code: &SyntaxNode,
         restrict_range: &Option<FileRange>,
         sema: &'sema Semantics<'db, ra_ide_db::RootDatabase>,
     ) -> Result<Match, MatchFailed> {
-        let mut match_state =
-            MatchState { sema, restrict_range: restrict_range.clone(), match_out: None };
-        let match_inputs = MatchInputs { ssr_pattern: &rule.pattern };
-        let pattern_tree = rule.pattern.tree_for_kind(code.kind())?;
+        let match_state = Matcher { sema, restrict_range: restrict_range.clone(), rule };
         // First pass at matching, where we check that node types and idents match.
-        match_state.attempt_match_node(&match_inputs, &pattern_tree, code)?;
+        match_state.attempt_match_node(&mut Phase::First, &rule.pattern.node, code)?;
         match_state.validate_range(&sema.original_range(code))?;
-        match_state.match_out = Some(Match {
-            range: sema.original_range(code).range,
+        let mut the_match = Match {
+            range: sema.original_range(code),
             matched_node: code.clone(),
             placeholder_values: FxHashMap::default(),
             ignored_comments: Vec::new(),
-            template: rule.template.clone(),
-        });
+            rule_index: rule.index,
+            depth: 0,
+            rendered_template_paths: FxHashMap::default(),
+        };
         // Second matching pass, where we record placeholder matches, ignored comments and maybe do
         // any other more expensive checks that we didn't want to do on the first pass.
-        match_state.attempt_match_node(&match_inputs, &pattern_tree, code)?;
-        Ok(match_state.match_out.unwrap())
+        match_state.attempt_match_node(
+            &mut Phase::Second(&mut the_match),
+            &rule.pattern.node,
+            code,
+        )?;
+        the_match.depth = sema.ancestors_with_macros(the_match.matched_node.clone()).count();
+        if let Some(template) = &rule.template {
+            the_match.render_template_paths(template, sema)?;
+        }
+        Ok(the_match)
     }
 
     /// Checks that `range` is within the permitted range if any. This is applicable when we're
@@ -162,79 +167,91 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
     }
 
     fn attempt_match_node(
-        &mut self,
-        match_inputs: &MatchInputs,
+        &self,
+        phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
     ) -> Result<(), MatchFailed> {
         // Handle placeholders.
-        if let Some(placeholder) =
-            match_inputs.get_placeholder(&SyntaxElement::Node(pattern.clone()))
-        {
-            if self.match_out.is_none() {
-                return Ok(());
+        if let Some(placeholder) = self.get_placeholder(&SyntaxElement::Node(pattern.clone())) {
+            for constraint in &placeholder.constraints {
+                self.check_constraint(constraint, code)?;
             }
-            let original_range = self.sema.original_range(code);
-            // We validated the range for the node when we started the match, so the placeholder
-            // probably can't fail range validation, but just to be safe...
-            self.validate_range(&original_range)?;
-            if let Some(match_out) = &mut self.match_out {
-                match_out.placeholder_values.insert(
+            if let Phase::Second(matches_out) = phase {
+                let original_range = self.sema.original_range(code);
+                // We validated the range for the node when we started the match, so the placeholder
+                // probably can't fail range validation, but just to be safe...
+                self.validate_range(&original_range)?;
+                matches_out.placeholder_values.insert(
                     Var(placeholder.ident.to_string()),
                     PlaceholderMatch::new(code, original_range),
                 );
             }
             return Ok(());
         }
-        // Non-placeholders.
+        // We allow a UFCS call to match a method call, provided they resolve to the same function.
+        if let Some(pattern_function) = self.rule.pattern.ufcs_function_calls.get(pattern) {
+            if let (Some(pattern), Some(code)) =
+                (ast::CallExpr::cast(pattern.clone()), ast::MethodCallExpr::cast(code.clone()))
+            {
+                return self.attempt_match_ufcs(phase, &pattern, &code, *pattern_function);
+            }
+        }
         if pattern.kind() != code.kind() {
-            fail_match!("Pattern had a {:?}, code had {:?}", pattern.kind(), code.kind());
+            fail_match!(
+                "Pattern had `{}` ({:?}), code had `{}` ({:?})",
+                pattern.text(),
+                pattern.kind(),
+                code.text(),
+                code.kind()
+            );
         }
         // Some kinds of nodes have special handling. For everything else, we fall back to default
         // matching.
         match code.kind() {
-            SyntaxKind::RECORD_FIELD_LIST => {
-                self.attempt_match_record_field_list(match_inputs, pattern, code)
+            SyntaxKind::RECORD_EXPR_FIELD_LIST => {
+                self.attempt_match_record_field_list(phase, pattern, code)
             }
-            SyntaxKind::TOKEN_TREE => self.attempt_match_token_tree(match_inputs, pattern, code),
-            _ => self.attempt_match_node_children(match_inputs, pattern, code),
+            SyntaxKind::TOKEN_TREE => self.attempt_match_token_tree(phase, pattern, code),
+            SyntaxKind::PATH => self.attempt_match_path(phase, pattern, code),
+            _ => self.attempt_match_node_children(phase, pattern, code),
         }
     }
 
     fn attempt_match_node_children(
-        &mut self,
-        match_inputs: &MatchInputs,
+        &self,
+        phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
     ) -> Result<(), MatchFailed> {
         self.attempt_match_sequences(
-            match_inputs,
+            phase,
             PatternIterator::new(pattern),
             code.children_with_tokens(),
         )
     }
 
     fn attempt_match_sequences(
-        &mut self,
-        match_inputs: &MatchInputs,
+        &self,
+        phase: &mut Phase,
         pattern_it: PatternIterator,
         mut code_it: SyntaxElementChildren,
     ) -> Result<(), MatchFailed> {
         let mut pattern_it = pattern_it.peekable();
         loop {
-            match self.next_non_trivial(&mut code_it) {
+            match phase.next_non_trivial(&mut code_it) {
                 None => {
                     if let Some(p) = pattern_it.next() {
-                        fail_match!("Part of the pattern was unmached: {:?}", p);
+                        fail_match!("Part of the pattern was unmatched: {:?}", p);
                     }
                     return Ok(());
                 }
                 Some(SyntaxElement::Token(c)) => {
-                    self.attempt_match_token(&mut pattern_it, &c)?;
+                    self.attempt_match_token(phase, &mut pattern_it, &c)?;
                 }
                 Some(SyntaxElement::Node(c)) => match pattern_it.next() {
                     Some(SyntaxElement::Node(p)) => {
-                        self.attempt_match_node(match_inputs, &p, &c)?;
+                        self.attempt_match_node(phase, &p, &c)?;
                     }
                     Some(p) => fail_match!("Pattern wanted '{}', code has {}", p, c.text()),
                     None => fail_match!("Pattern reached end, code has {}", c.text()),
@@ -244,11 +261,12 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
     }
 
     fn attempt_match_token(
-        &mut self,
+        &self,
+        phase: &mut Phase,
         pattern: &mut Peekable<PatternIterator>,
         code: &ra_syntax::SyntaxToken,
     ) -> Result<(), MatchFailed> {
-        self.record_ignored_comments(code);
+        phase.record_ignored_comments(code);
         // Ignore whitespace and comments.
         if code.kind().is_trivia() {
             return Ok(());
@@ -294,18 +312,94 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
         Ok(())
     }
 
+    fn check_constraint(
+        &self,
+        constraint: &Constraint,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        match constraint {
+            Constraint::Kind(kind) => {
+                kind.matches(code)?;
+            }
+            Constraint::Not(sub) => {
+                if self.check_constraint(&*sub, code).is_ok() {
+                    fail_match!("Constraint {:?} failed for '{}'", constraint, code.text());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Paths are matched based on whether they refer to the same thing, even if they're written
+    /// differently.
+    fn attempt_match_path(
+        &self,
+        phase: &mut Phase,
+        pattern: &SyntaxNode,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        if let Some(pattern_resolved) = self.rule.pattern.resolved_paths.get(pattern) {
+            let pattern_path = ast::Path::cast(pattern.clone()).unwrap();
+            let code_path = ast::Path::cast(code.clone()).unwrap();
+            if let (Some(pattern_segment), Some(code_segment)) =
+                (pattern_path.segment(), code_path.segment())
+            {
+                // Match everything within the segment except for the name-ref, which is handled
+                // separately via comparing what the path resolves to below.
+                self.attempt_match_opt(
+                    phase,
+                    pattern_segment.type_arg_list(),
+                    code_segment.type_arg_list(),
+                )?;
+                self.attempt_match_opt(
+                    phase,
+                    pattern_segment.param_list(),
+                    code_segment.param_list(),
+                )?;
+            }
+            if matches!(phase, Phase::Second(_)) {
+                let resolution = self
+                    .sema
+                    .resolve_path(&code_path)
+                    .ok_or_else(|| match_error!("Failed to resolve path `{}`", code.text()))?;
+                if pattern_resolved.resolution != resolution {
+                    fail_match!("Pattern had path `{}` code had `{}`", pattern.text(), code.text());
+                }
+            }
+        } else {
+            return self.attempt_match_node_children(phase, pattern, code);
+        }
+        Ok(())
+    }
+
+    fn attempt_match_opt<T: AstNode>(
+        &self,
+        phase: &mut Phase,
+        pattern: Option<T>,
+        code: Option<T>,
+    ) -> Result<(), MatchFailed> {
+        match (pattern, code) {
+            (Some(p), Some(c)) => self.attempt_match_node(phase, &p.syntax(), &c.syntax()),
+            (None, None) => Ok(()),
+            (Some(p), None) => fail_match!("Pattern `{}` had nothing to match", p.syntax().text()),
+            (None, Some(c)) => {
+                fail_match!("Nothing in pattern to match code `{}`", c.syntax().text())
+            }
+        }
+    }
+
     /// We want to allow the records to match in any order, so we have special matching logic for
     /// them.
     fn attempt_match_record_field_list(
-        &mut self,
-        match_inputs: &MatchInputs,
+        &self,
+        phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
     ) -> Result<(), MatchFailed> {
         // Build a map keyed by field name.
         let mut fields_by_name = FxHashMap::default();
         for child in code.children() {
-            if let Some(record) = ast::RecordField::cast(child.clone()) {
+            if let Some(record) = ast::RecordExprField::cast(child.clone()) {
                 if let Some(name) = record.field_name() {
                     fields_by_name.insert(name.text().clone(), child.clone());
                 }
@@ -314,11 +408,11 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
         for p in pattern.children_with_tokens() {
             if let SyntaxElement::Node(p) = p {
                 if let Some(name_element) = p.first_child_or_token() {
-                    if match_inputs.get_placeholder(&name_element).is_some() {
+                    if self.get_placeholder(&name_element).is_some() {
                         // If the pattern is using placeholders for field names then order
                         // independence doesn't make sense. Fall back to regular ordered
                         // matching.
-                        return self.attempt_match_node_children(match_inputs, pattern, code);
+                        return self.attempt_match_node_children(phase, pattern, code);
                     }
                     if let Some(ident) = only_ident(name_element) {
                         let code_record = fields_by_name.remove(ident.text()).ok_or_else(|| {
@@ -327,7 +421,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
                                 ident
                             )
                         })?;
-                        self.attempt_match_node(match_inputs, &p, &code_record)?;
+                        self.attempt_match_node(phase, &p, &code_record)?;
                     }
                 }
             }
@@ -347,16 +441,15 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
     /// pattern matches the macro invocation. For matches within the macro call, we'll already have
     /// expanded the macro.
     fn attempt_match_token_tree(
-        &mut self,
-        match_inputs: &MatchInputs,
+        &self,
+        phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &ra_syntax::SyntaxNode,
     ) -> Result<(), MatchFailed> {
         let mut pattern = PatternIterator::new(pattern).peekable();
         let mut children = code.children_with_tokens();
         while let Some(child) = children.next() {
-            if let Some(placeholder) = pattern.peek().and_then(|p| match_inputs.get_placeholder(p))
-            {
+            if let Some(placeholder) = pattern.peek().and_then(|p| self.get_placeholder(p)) {
                 pattern.next();
                 let next_pattern_token = pattern
                     .peek()
@@ -382,7 +475,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
                                 if Some(first_token.to_string()) == next_pattern_token {
                                     if let Some(SyntaxElement::Node(p)) = pattern.next() {
                                         // We have a subtree that starts with the next token in our pattern.
-                                        self.attempt_match_token_tree(match_inputs, &p, &n)?;
+                                        self.attempt_match_token_tree(phase, &p, &n)?;
                                         break;
                                     }
                                 }
@@ -391,7 +484,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
                     };
                     last_matched_token = next;
                 }
-                if let Some(match_out) = &mut self.match_out {
+                if let Phase::Second(match_out) = phase {
                     match_out.placeholder_values.insert(
                         Var(placeholder.ident.to_string()),
                         PlaceholderMatch::from_range(FileRange {
@@ -407,11 +500,11 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
             // Match literal (non-placeholder) tokens.
             match child {
                 SyntaxElement::Token(token) => {
-                    self.attempt_match_token(&mut pattern, &token)?;
+                    self.attempt_match_token(phase, &mut pattern, &token)?;
                 }
                 SyntaxElement::Node(node) => match pattern.next() {
                     Some(SyntaxElement::Node(p)) => {
-                        self.attempt_match_token_tree(match_inputs, &p, &node)?;
+                        self.attempt_match_token_tree(phase, &p, &node)?;
                     }
                     Some(SyntaxElement::Token(p)) => fail_match!(
                         "Pattern has token '{}', code has subtree '{}'",
@@ -428,6 +521,65 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
         Ok(())
     }
 
+    fn attempt_match_ufcs(
+        &self,
+        phase: &mut Phase,
+        pattern: &ast::CallExpr,
+        code: &ast::MethodCallExpr,
+        pattern_function: hir::Function,
+    ) -> Result<(), MatchFailed> {
+        use ast::ArgListOwner;
+        let code_resolved_function = self
+            .sema
+            .resolve_method_call(code)
+            .ok_or_else(|| match_error!("Failed to resolve method call"))?;
+        if pattern_function != code_resolved_function {
+            fail_match!("Method call resolved to a different function");
+        }
+        // Check arguments.
+        let mut pattern_args = pattern
+            .arg_list()
+            .ok_or_else(|| match_error!("Pattern function call has no args"))?
+            .args();
+        self.attempt_match_opt(phase, pattern_args.next(), code.expr())?;
+        let mut code_args =
+            code.arg_list().ok_or_else(|| match_error!("Code method call has no args"))?.args();
+        loop {
+            match (pattern_args.next(), code_args.next()) {
+                (None, None) => return Ok(()),
+                (p, c) => self.attempt_match_opt(phase, p, c)?,
+            }
+        }
+    }
+
+    fn get_placeholder(&self, element: &SyntaxElement) -> Option<&Placeholder> {
+        only_ident(element.clone()).and_then(|ident| self.rule.get_placeholder(&ident))
+    }
+}
+
+impl Match {
+    fn render_template_paths(
+        &mut self,
+        template: &ResolvedPattern,
+        sema: &Semantics<ra_ide_db::RootDatabase>,
+    ) -> Result<(), MatchFailed> {
+        let module = sema
+            .scope(&self.matched_node)
+            .module()
+            .ok_or_else(|| match_error!("Matched node isn't in a module"))?;
+        for (path, resolved_path) in &template.resolved_paths {
+            if let hir::PathResolution::Def(module_def) = resolved_path.resolution {
+                let mod_path = module.find_use_path(sema.db, module_def).ok_or_else(|| {
+                    match_error!("Failed to render template path `{}` at match location")
+                })?;
+                self.rendered_template_paths.insert(path.clone(), mod_path);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Phase<'_> {
     fn next_non_trivial(&mut self, code_it: &mut SyntaxElementChildren) -> Option<SyntaxElement> {
         loop {
             let c = code_it.next();
@@ -443,7 +595,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
 
     fn record_ignored_comments(&mut self, token: &SyntaxToken) {
         if token.kind() == SyntaxKind::COMMENT {
-            if let Some(match_out) = &mut self.match_out {
+            if let Phase::Second(match_out) = self {
                 if let Some(comment) = ast::Comment::cast(token.clone()) {
                     match_out.ignored_comments.push(comment);
                 }
@@ -452,13 +604,6 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
     }
 }
 
-impl MatchInputs<'_> {
-    fn get_placeholder(&self, element: &SyntaxElement) -> Option<&Placeholder> {
-        only_ident(element.clone())
-            .and_then(|ident| self.ssr_pattern.placeholders_by_stand_in.get(ident.text()))
-    }
-}
-
 fn is_closing_token(kind: SyntaxKind) -> bool {
     kind == SyntaxKind::R_PAREN || kind == SyntaxKind::R_CURLY || kind == SyntaxKind::R_BRACK
 }
@@ -495,25 +640,18 @@ impl PlaceholderMatch {
     }
 }
 
-impl SsrPattern {
-    pub(crate) fn tree_for_kind(&self, kind: SyntaxKind) -> Result<&SyntaxNode, MatchFailed> {
-        let (tree, kind_name) = if ast::Expr::can_cast(kind) {
-            (&self.expr, "expression")
-        } else if ast::TypeRef::can_cast(kind) {
-            (&self.type_ref, "type reference")
-        } else if ast::ModuleItem::can_cast(kind) {
-            (&self.item, "item")
-        } else if ast::Path::can_cast(kind) {
-            (&self.path, "path")
-        } else if ast::Pat::can_cast(kind) {
-            (&self.pattern, "pattern")
-        } else {
-            fail_match!("Matching nodes of kind {:?} is not supported", kind);
+impl NodeKind {
+    fn matches(&self, node: &SyntaxNode) -> Result<(), MatchFailed> {
+        let ok = match self {
+            Self::Literal => {
+                mark::hit!(literal_constraint);
+                ast::Literal::can_cast(node.kind())
+            }
         };
-        match tree {
-            Some(tree) => Ok(tree),
-            None => fail_match!("Pattern cannot be parsed as a {}", kind_name),
+        if !ok {
+            fail_match!("Code '{}' isn't of kind {:?}", node.text(), self);
         }
+        Ok(())
     }
 }
 
@@ -561,18 +699,17 @@ impl PatternIterator {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::MatchFinder;
+    use crate::{MatchFinder, SsrRule};
 
     #[test]
     fn parse_match_replace() {
         let rule: SsrRule = "foo($x) ==>> bar($x)".parse().unwrap();
-        let input = "fn main() { foo(1+2); }";
+        let input = "fn foo() {} fn bar() {} fn main() { foo(1+2); }";
 
-        use ra_db::fixture::WithFixture;
-        let (db, file_id) = ra_ide_db::RootDatabase::with_single_file(input);
-        let mut match_finder = MatchFinder::new(&db);
-        match_finder.add_rule(rule);
-        let matches = match_finder.find_matches_in_file(file_id);
+        let (db, position, selections) = crate::tests::single_file(input);
+        let mut match_finder = MatchFinder::in_context(&db, position, selections);
+        match_finder.add_rule(rule).unwrap();
+        let matches = match_finder.matches();
         assert_eq!(matches.matches.len(), 1);
         assert_eq!(matches.matches[0].matched_node.text(), "foo(1+2)");
         assert_eq!(matches.matches[0].placeholder_values.len(), 1);
@@ -585,9 +722,11 @@ mod tests {
             "1+2"
         );
 
-        let edit = crate::replacing::matches_to_edit(&matches, input);
+        let edits = match_finder.edits();
+        assert_eq!(edits.len(), 1);
+        let edit = &edits[0];
         let mut after = input.to_string();
-        edit.apply(&mut after);
-        assert_eq!(after, "fn main() { bar(1+2); }");
+        edit.edit.apply(&mut after);
+        assert_eq!(after, "fn foo() {} fn bar() {} fn main() { bar(1+2); }");
     }
 }