ssr/matching: Ignore trailing semicolon in let stmt, take 2

Author: MarijnS95

crates/ssr/src/matching.rs

@@ -23,7 +23,8 @@ macro_rules! match_error {
                     Some(format!("{}", $e))
                 } else {
                     None
-                }
+                },
+                missing_semicolon: false,
             }
     }};
     ($fmt:expr, $($arg:tt)+) => {{
@@ -32,7 +33,8 @@ macro_rules! match_error {
                 Some(format!($fmt, $($arg)+))
             } else {
                 None
-            }
+            },
+            missing_semicolon: false,
         }
     }};
 }
@@ -81,7 +83,9 @@ pub(crate) struct MatchFailureReason {
 pub(crate) struct MatchFailed {
     /// The reason why we failed to match. Only present when debug_active true in call to
     /// `get_match`.
+    // FIXME: Turn this into an enum?
     pub(crate) reason: Option<String>,
+    pub(crate) missing_semicolon: bool,
 }
 
 /// Checks if `code` matches the search pattern found in `search_scope`, returning information about
@@ -215,10 +219,29 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
             }
             SyntaxKind::TOKEN_TREE => self.attempt_match_token_tree(phase, pattern, code),
             SyntaxKind::PATH => self.attempt_match_path(phase, pattern, code),
+            SyntaxKind::LET_STMT => self.attempt_match_let(phase, pattern, code),
             _ => self.attempt_match_node_children(phase, pattern, code),
         }
     }
 
+    fn attempt_match_let(
+        &self,
+        phase: &mut Phase,
+        pattern: &SyntaxNode,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        let pattern_it = PatternIterator::new(pattern);
+        let code_it = code.children_with_tokens();
+
+        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(())
+            }
+            res => res,
+        }
+    }
+
     fn attempt_match_node_children(
         &self,
         phase: &mut Phase,
@@ -283,10 +306,6 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
             if p.kind() == SyntaxKind::COMMA && is_closing_token(code.kind()) {
                 pattern.next();
             }
-        } else if code.kind() == SyntaxKind::SEMICOLON {
-            // If the pattern ends but the code still has a trailing semicolon, accept the match.
-            // Allows to match `let x = y; ...` with `let $a = $b`.
-            return Ok(());
         }
 
         // Consume an element from the pattern and make sure it matches.
@@ -312,6 +331,9 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                 );
             }
             None => {
+                if code.kind() == SyntaxKind::SEMICOLON {
+                    return Err(MatchFailed { reason: None, missing_semicolon: true });
+                }
                 fail_match!("Pattern exhausted, while code remains: `{}`", code.text());
             }
         }