ssr/matching: Implement match ranges

Author: MarijnS95

crates/ssr/src/lib.rs

@@ -327,7 +327,10 @@ impl SsrMatches {
 
 impl Match {
     pub fn matched_text(&self) -> String {
-        self.matched_node.text().to_string()
+        // TODO: There is probably a way to get (the text of) a SyntaxNode with a TextRange?
+        let mut s = self.matched_node.text().to_string();
+        s.truncate(self.range.range.len().into());
+        s
     }
 }
 

crates/ssr/src/matching.rs

@@ -122,6 +122,16 @@ enum Phase<'a> {
     Second(&'a mut Match),
 }
 
+#[derive(Debug)]
+enum MatchRange {
+    Full,
+    // TODO: Should be an Err(), so that it can be threaded up?
+    // Otherwise all code returning a MatchRange must check that on success and take it into account, even if it's only a "high level" thing for now
+    // After all, a partial match can only be triggered if the pattern does not match _anymore_, but did up to a certain point (ie. pattern
+    // exhausted but the current SyntaxNode still has a trailing semicolon)
+    Partial(FileRange),
+}
+
 impl<'db, 'sema> Matcher<'db, 'sema> {
     fn try_match(
         rule: &ResolvedRule,
@@ -131,10 +141,17 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
     ) -> Result<Match, MatchFailed> {
         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(&mut Phase::First, &rule.pattern.node, code)?;
-        match_state.validate_range(&sema.original_range(code))?;
+        let matched_range =
+            match_state.attempt_match_node(&mut Phase::First, &rule.pattern.node, code)?;
+
+        let range = match matched_range {
+            MatchRange::Full => sema.original_range(code),
+            MatchRange::Partial(r) => r,
+        };
+
+        match_state.validate_range(&range)?;
         let mut the_match = Match {
-            range: sema.original_range(code),
+            range,
             matched_node: code.clone(),
             placeholder_values: FxHashMap::default(),
             ignored_comments: Vec::new(),
@@ -175,14 +192,16 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         // Handle placeholders.
         if let Some(placeholder) = self.get_placeholder_for_node(pattern) {
             for constraint in &placeholder.constraints {
                 self.check_constraint(constraint, code)?;
             }
             if let Phase::Second(matches_out) = phase {
-                let original_range = self.sema.original_range(code);
+                let mut original_range = self.sema.original_range(code);
+                original_range.range =
+                    original_range.range.intersect(matches_out.range.range).unwrap();
                 // 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)?;
@@ -191,7 +210,8 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                     PlaceholderMatch::new(Some(code), original_range),
                 );
             }
-            return Ok(());
+            // Range not relevant here
+            return Ok(MatchRange::Full);
         }
         // We allow a UFCS call to match a method call, provided they resolve to the same function.
         if let Some(pattern_ufcs) = self.rule.pattern.ufcs_function_calls.get(pattern) {
@@ -229,14 +249,21 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         let pattern_it = PatternIterator::new(pattern);
         let code_it = code.children_with_tokens();
 
+        // WIP: Only allow missing semicolons on `let = ...(;)`
         match self.attempt_match_sequences(phase, pattern_it, code_it) {
-            // For now this error is only surfaced when the pattern is empty
-            Err(MatchFailed { missing_semicolon: true, .. }) /* if pattern_it.peek().is_none() */ => {
-                Ok(())
+            Err(MatchFailed { missing_semicolon: true, .. }) => {
+                let mut original_range = self.sema.original_range(code);
+                let text_range = original_range.range;
+                original_range.range = syntax::TextRange::new(
+                    text_range.start(),
+                    text_range.end() - syntax::TextSize::from(1),
+                );
+
+                Ok(MatchRange::Partial(original_range))
             }
             res => res,
         }
@@ -247,7 +274,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         self.attempt_match_sequences(
             phase,
             PatternIterator::new(pattern),
@@ -260,15 +287,15 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern_it: PatternIterator,
         mut code_it: SyntaxElementChildren,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         let mut pattern_it = pattern_it.peekable();
         loop {
             match phase.next_non_trivial(&mut code_it) {
                 None => {
                     if let Some(p) = pattern_it.next() {
                         fail_match!("Part of the pattern was unmatched: {:?}", p);
                     }
-                    return Ok(());
+                    return Ok(MatchRange::Full);
                 }
                 Some(SyntaxElement::Token(c)) => {
                     self.attempt_match_token(phase, &mut pattern_it, &c)?;
@@ -332,6 +359,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
             }
             None => {
                 if code.kind() == SyntaxKind::SEMICOLON {
+                    // TODO: MatchRange::Partial?
                     return Err(MatchFailed { reason: None, missing_semicolon: true });
                 }
                 fail_match!("Pattern exhausted, while code remains: `{}`", code.text());
@@ -365,7 +393,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, 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();
@@ -397,18 +425,18 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         } else {
             return self.attempt_match_node_children(phase, pattern, code);
         }
-        Ok(())
+        Ok(MatchRange::Full)
     }
 
     fn attempt_match_opt<T: AstNode>(
         &self,
         phase: &mut Phase,
         pattern: Option<T>,
         code: Option<T>,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         match (pattern, code) {
             (Some(p), Some(c)) => self.attempt_match_node(phase, &p.syntax(), &c.syntax()),
-            (None, None) => Ok(()),
+            (None, None) => Ok(MatchRange::Full),
             (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())
@@ -423,7 +451,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         // Build a map keyed by field name.
         let mut fields_by_name = FxHashMap::default();
         for child in code.children() {
@@ -461,7 +489,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                 unmatched_fields
             );
         }
-        Ok(())
+        Ok(MatchRange::Full)
     }
 
     /// Outside of token trees, a placeholder can only match a single AST node, whereas in a token
@@ -473,7 +501,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern: &SyntaxNode,
         code: &syntax::SyntaxNode,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         let mut pattern = PatternIterator::new(pattern).peekable();
         let mut children = code.children_with_tokens();
         while let Some(child) = children.next() {
@@ -546,15 +574,15 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         if let Some(p) = pattern.next() {
             fail_match!("Reached end of token tree in code, but pattern still has {:?}", p);
         }
-        Ok(())
+        Ok(MatchRange::Full)
     }
 
     fn attempt_match_ufcs_to_method_call(
         &self,
         phase: &mut Phase,
         pattern_ufcs: &UfcsCallInfo,
         code: &ast::MethodCallExpr,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         use ast::ArgListOwner;
         let code_resolved_function = self
             .sema
@@ -603,8 +631,10 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
             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)?,
+                (None, None) => return Ok(MatchRange::Full),
+                (p, c) => {
+                    let _ = self.attempt_match_opt(phase, p, c)?;
+                }
             }
         }
     }
@@ -614,7 +644,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         phase: &mut Phase,
         pattern_ufcs: &UfcsCallInfo,
         code: &ast::CallExpr,
-    ) -> Result<(), MatchFailed> {
+    ) -> Result<MatchRange, MatchFailed> {
         use ast::ArgListOwner;
         // Check that the first argument is the expected type.
         if let (Some(pattern_type), Some(expr)) = (