clippy_dev: Add specialized helpers for finding identifiers to the token cursor.

Author: Jarcho

clippy_dev/src/new_lint.rs

@@ -523,8 +523,8 @@ fn parse_mod_file(path: &Path, contents: &str) -> (&'static str, usize) {
     let mut decl_end = None;
     let mut cursor = Cursor::new(contents);
     let mut captures = [Capture::EMPTY];
-    while let Some(name) = cursor.find_capture_pat(CaptureIdent) {
-        match name {
+    while let Some(name) = cursor.find_any_ident() {
+        match cursor.get_text(name) {
             "declare_clippy_lint" => {
                 if cursor.match_all(&[Bang, OpenBrace], &mut []) && cursor.find_pat(CloseBrace) {
                     decl_end = Some(cursor.pos());

clippy_dev/src/parse.rs

@@ -103,15 +103,14 @@ fn parse_clippy_lint_decls(path: &Path, contents: &str, module: &str, lints: &mu
 
     let mut cursor = Cursor::new(contents);
     let mut captures = [Capture::EMPTY; 2];
-    while cursor.find_pat(Ident("declare_clippy_lint")) {
-        let start = cursor.pos() as usize - "declare_clippy_lint".len();
+    while let Some(start) = cursor.find_ident("declare_clippy_lint") {
         if cursor.match_all(DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) {
             lints.push(Lint {
                 name: cursor.get_text(captures[0]).to_lowercase(),
                 group: cursor.get_text(captures[1]).into(),
                 module: module.into(),
                 path: path.into(),
-                declaration_range: start..cursor.pos() as usize,
+                declaration_range: start as usize..cursor.pos() as usize,
             });
         }
     }
@@ -150,11 +149,11 @@ pub fn read_deprecated_lints() -> (Vec<DeprecatedLint>, Vec<RenamedLint>) {
 
     // First instance is the macro definition.
     assert!(
-        cursor.find_pat(Ident("declare_with_version")),
+        cursor.find_ident("declare_with_version").is_some(),
         "error reading deprecated lints"
     );
 
-    if cursor.find_pat(Ident("declare_with_version")) && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
+    if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
         while cursor.match_all(DECL_TOKENS, &mut captures) {
             deprecated.push(DeprecatedLint {
                 name: parse_str_single_line(path.as_ref(), cursor.get_text(captures[1])),
@@ -166,7 +165,7 @@ pub fn read_deprecated_lints() -> (Vec<DeprecatedLint>, Vec<RenamedLint>) {
         panic!("error reading deprecated lints");
     }
 
-    if cursor.find_pat(Ident("declare_with_version")) && cursor.match_all(RENAMED_TOKENS, &mut []) {
+    if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(RENAMED_TOKENS, &mut []) {
         while cursor.match_all(DECL_TOKENS, &mut captures) {
             renamed.push(RenamedLint {
                 old_name: parse_str_single_line(path.as_ref(), cursor.get_text(captures[1])),

clippy_dev/src/parse/cursor.rs

@@ -178,6 +178,47 @@ impl<'txt> Cursor<'txt> {
         }
     }
 
+    /// Consumes all tokens until the specified identifier is found and returns its
+    /// position. Returns `None` if the identifier could not be found.
+    ///
+    /// The cursor will be positioned immediately after the identifier, or at the end if
+    /// it is not.
+    pub fn find_ident(&mut self, ident: &str) -> Option<u32> {
+        loop {
+            match self.next_token.kind {
+                TokenKind::Ident if self.peek_text() == ident => {
+                    let pos = self.pos;
+                    self.step();
+                    return Some(pos);
+                },
+                TokenKind::Eof => return None,
+                _ => self.step(),
+            }
+        }
+    }
+
+    /// Consumes all tokens until the next identifier is found and captures it. Returns
+    /// `None` if no identifier could be found.
+    ///
+    /// The cursor will be positioned immediately after the identifier, or at the end if
+    /// it is not.
+    pub fn find_any_ident(&mut self) -> Option<Capture> {
+        loop {
+            match self.next_token.kind {
+                TokenKind::Ident => {
+                    let res = Capture {
+                        pos: self.pos,
+                        len: self.next_token.len,
+                    };
+                    self.step();
+                    return Some(res);
+                },
+                TokenKind::Eof => return None,
+                _ => self.step(),
+            }
+        }
+    }
+
     /// Continually attempt to match the pattern on subsequent tokens until a match is
     /// found. Returns whether the pattern was successfully matched.
     ///
@@ -195,20 +236,6 @@ impl<'txt> Cursor<'txt> {
         true
     }
 
-    /// The same as [`Self::find_pat`], but returns a capture as well.
-    #[must_use]
-    pub fn find_capture_pat(&mut self, pat: Pat<'_>) -> Option<&'txt str> {
-        let mut capture = Capture::EMPTY;
-        let mut captures = slice::from_mut(&mut capture).iter_mut();
-        while !self.match_impl(pat, &mut captures) {
-            self.step();
-            if self.at_end() {
-                return None;
-            }
-        }
-        Some(self.get_text(capture))
-    }
-
     /// Attempts to match a sequence of patterns at the current position. Returns whether
     /// all patterns were successfully matched.
     ///
@@ -221,6 +248,16 @@ impl<'txt> Cursor<'txt> {
     #[must_use]
     pub fn match_all(&mut self, pats: &[Pat<'_>], captures: &mut [Capture]) -> bool {
         let mut captures = captures.iter_mut();
-        pats.iter().all(|&t| self.match_impl(t, &mut captures))
+        pats.iter().all(|&p| self.match_impl(p, &mut captures))
+    }
+
+    /// Attempts to match a single pattern at the current position. Returns whether the
+    /// pattern was successfully matched.
+    ///
+    /// If the pattern attempts to capture anything this will panic. If the match fails
+    /// the cursor will be positioned at the first failing token.
+    #[must_use]
+    pub fn match_pat(&mut self, pat: Pat<'_>) -> bool {
+        self.match_impl(pat, &mut [].iter_mut())
     }
 }

clippy_dev/src/rename_lint.rs

@@ -304,17 +304,16 @@ fn file_update_fn<'a, 'b>(
                         // mod lint_name
                         "mod" => {
                             if !matches!(mod_edit, ModEdit::None)
-                                && cursor.match_all(&[cursor::Pat::CaptureIdent], &mut captures)
-                                && cursor.get_text(captures[0]) == old_name
+                                && let Some(pos) = cursor.find_ident(old_name)
                             {
                                 match mod_edit {
                                     ModEdit::Rename => {
-                                        dst.push_str(&src[copy_pos as usize..captures[0].pos as usize]);
+                                        dst.push_str(&src[copy_pos as usize..pos as usize]);
                                         dst.push_str(new_name);
                                         copy_pos = cursor.pos();
                                         changed = true;
                                     },
-                                    ModEdit::Delete if cursor.match_all(&[cursor::Pat::Semi], &mut []) => {
+                                    ModEdit::Delete if cursor.match_pat(cursor::Pat::Semi) => {
                                         let mut start = &src[copy_pos as usize..match_start as usize];
                                         if start.ends_with("\n\n") {
                                             start = &start[..start.len() - 1];
@@ -333,7 +332,7 @@ fn file_update_fn<'a, 'b>(
                         // lint_name::
                         name if matches!(mod_edit, ModEdit::Rename) && name == old_name => {
                             let name_end = cursor.pos();
-                            if cursor.match_all(&[cursor::Pat::DoubleColon], &mut []) {
+                            if cursor.match_pat(cursor::Pat::DoubleColon) {
                                 dst.push_str(&src[copy_pos as usize..match_start as usize]);
                                 dst.push_str(new_name);
                                 copy_pos = name_end;