clippy_dev: Move all parsing within a parse context.

Jarcho · Jarcho · commit fcfab5fe4b33 · 2025-10-22T19:09:23.000-04:00
diff --git a/clippy_dev/src/deprecate_lint.rs b/clippy_dev/src/deprecate_lint.rs
@@ -1,4 +1,4 @@
-use crate::parse::{DeprecatedLint, Lint, find_lint_decls, read_deprecated_lints};
+use crate::parse::{DeprecatedLint, Lint, ParseCx};
 use crate::update_lints::generate_lint_files;
 use crate::utils::{UpdateMode, Version};
 use std::ffi::OsStr;
@@ -14,9 +14,9 @@ use std::{fs, io};
 /// # Panics
 ///
 /// If a file path could not read from or written to
-pub fn deprecate(clippy_version: Version, name: &str, reason: &str) {
-    let mut lints = find_lint_decls();
-    let (mut deprecated_lints, renamed_lints) = read_deprecated_lints();
+pub fn deprecate<'cx>(cx: ParseCx<'cx>, clippy_version: Version, name: &'cx str, reason: &'cx str) {
+    let mut lints = cx.find_lint_decls();
+    let (mut deprecated_lints, renamed_lints) = cx.read_deprecated_lints();
 
     let Some(lint) = lints.iter().find(|l| l.name == name) else {
         eprintln!("error: failed to find lint `{name}`");
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
@@ -34,7 +34,8 @@ pub mod setup;
 pub mod sync;
 pub mod update_lints;
 
+mod parse;
 mod utils;
-pub use utils::{ClippyInfo, UpdateMode};
 
-mod parse;
+pub use self::parse::{ParseCx, new_parse_cx};
+pub use self::utils::{ClippyInfo, UpdateMode};
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
@@ -4,8 +4,8 @@
 
 use clap::{Args, Parser, Subcommand};
 use clippy_dev::{
-    ClippyInfo, UpdateMode, deprecate_lint, dogfood, fmt, lint, new_lint, release, rename_lint, serve, setup, sync,
-    update_lints,
+    ClippyInfo, UpdateMode, deprecate_lint, dogfood, fmt, lint, new_lint, new_parse_cx, release, rename_lint, serve,
+    setup, sync, update_lints,
 };
 use std::env;
 
@@ -27,15 +27,15 @@ fn main() {
             allow_no_vcs,
         } => dogfood::dogfood(fix, allow_dirty, allow_staged, allow_no_vcs),
         DevCommand::Fmt { check } => fmt::run(UpdateMode::from_check(check)),
-        DevCommand::UpdateLints { check } => update_lints::update(UpdateMode::from_check(check)),
+        DevCommand::UpdateLints { check } => new_parse_cx(|cx| update_lints::update(cx, UpdateMode::from_check(check))),
         DevCommand::NewLint {
             pass,
             name,
             category,
             r#type,
             msrv,
         } => match new_lint::create(clippy.version, pass, &name, &category, r#type.as_deref(), msrv) {
-            Ok(()) => update_lints::update(UpdateMode::Change),
+            Ok(()) => new_parse_cx(|cx| update_lints::update(cx, UpdateMode::Change)),
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
@@ -78,13 +78,18 @@ fn main() {
             old_name,
             new_name,
             uplift,
-        } => rename_lint::rename(
-            clippy.version,
-            &old_name,
-            new_name.as_ref().unwrap_or(&old_name),
-            uplift,
-        ),
-        DevCommand::Deprecate { name, reason } => deprecate_lint::deprecate(clippy.version, &name, &reason),
+        } => new_parse_cx(|cx| {
+            rename_lint::rename(
+                cx,
+                clippy.version,
+                &old_name,
+                new_name.as_ref().unwrap_or(&old_name),
+                uplift,
+            );
+        }),
+        DevCommand::Deprecate { name, reason } => {
+            new_parse_cx(|cx| deprecate_lint::deprecate(cx, clippy.version, &name, &reason));
+        },
         DevCommand::Sync(SyncCommand { subcommand }) => match subcommand {
             SyncSubcommand::UpdateNightly => sync::update_nightly(),
         },
diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
@@ -1,12 +1,20 @@
 pub mod cursor;
 
 use self::cursor::{Capture, Cursor};
-use crate::utils::{ErrAction, File, expect_action};
+use crate::utils::{ErrAction, File, Scoped, expect_action};
 use core::range::Range;
 use std::fs;
 use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
 
+pub struct ParseCxImpl;
+pub type ParseCx<'cx> = &'cx mut ParseCxImpl;
+
+/// Calls the given function inside a newly created parsing context.
+pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx, 'env, ParseCxImpl>) -> T) -> T {
+    f(&mut Scoped::new(ParseCxImpl))
+}
+
 pub struct Lint {
     pub name: String,
     pub group: String,
@@ -27,33 +35,101 @@ pub struct RenamedLint {
     pub version: String,
 }
 
-/// Finds all lint declarations (`declare_clippy_lint!`)
-#[must_use]
-pub fn find_lint_decls() -> Vec<Lint> {
-    let mut lints = Vec::with_capacity(1000);
-    let mut contents = String::new();
-    for e in expect_action(fs::read_dir("."), ErrAction::Read, ".") {
-        let e = expect_action(e, ErrAction::Read, ".");
-        if !expect_action(e.file_type(), ErrAction::Read, ".").is_dir() {
-            continue;
+impl ParseCxImpl {
+    /// Finds all lint declarations (`declare_clippy_lint!`)
+    #[must_use]
+    pub fn find_lint_decls(&mut self) -> Vec<Lint> {
+        let mut lints = Vec::with_capacity(1000);
+        let mut contents = String::new();
+        for e in expect_action(fs::read_dir("."), ErrAction::Read, ".") {
+            let e = expect_action(e, ErrAction::Read, ".");
+            if !expect_action(e.file_type(), ErrAction::Read, ".").is_dir() {
+                continue;
+            }
+            let Ok(mut name) = e.file_name().into_string() else {
+                continue;
+            };
+            if name.starts_with("clippy_lints") && name != "clippy_lints_internal" {
+                name.push_str("/src");
+                for (file, module) in read_src_with_module(name.as_ref()) {
+                    parse_clippy_lint_decls(
+                        file.path(),
+                        File::open_read_to_cleared_string(file.path(), &mut contents),
+                        &module,
+                        &mut lints,
+                    );
+                }
+            }
         }
-        let Ok(mut name) = e.file_name().into_string() else {
-            continue;
-        };
-        if name.starts_with("clippy_lints") && name != "clippy_lints_internal" {
-            name.push_str("/src");
-            for (file, module) in read_src_with_module(name.as_ref()) {
-                parse_clippy_lint_decls(
-                    file.path(),
-                    File::open_read_to_cleared_string(file.path(), &mut contents),
-                    &module,
-                    &mut lints,
-                );
+        lints.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
+        lints
+    }
+
+    #[must_use]
+    pub fn read_deprecated_lints(&mut self) -> (Vec<DeprecatedLint>, Vec<RenamedLint>) {
+        #[allow(clippy::enum_glob_use)]
+        use cursor::Pat::*;
+        #[rustfmt::skip]
+        static DECL_TOKENS: &[cursor::Pat<'_>] = &[
+            // #[clippy::version = "version"]
+            Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, CaptureLitStr, CloseBracket,
+            // ("first", "second"),
+            OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen, Comma,
+        ];
+        #[rustfmt::skip]
+        static DEPRECATED_TOKENS: &[cursor::Pat<'_>] = &[
+            // !{ DEPRECATED(DEPRECATED_VERSION) = [
+            Bang, OpenBrace, Ident("DEPRECATED"), OpenParen, Ident("DEPRECATED_VERSION"), CloseParen, Eq, OpenBracket,
+        ];
+        #[rustfmt::skip]
+        static RENAMED_TOKENS: &[cursor::Pat<'_>] = &[
+            // !{ RENAMED(RENAMED_VERSION) = [
+            Bang, OpenBrace, Ident("RENAMED"), OpenParen, Ident("RENAMED_VERSION"), CloseParen, Eq, OpenBracket,
+        ];
+
+        let path = "clippy_lints/src/deprecated_lints.rs";
+        let mut deprecated = Vec::with_capacity(30);
+        let mut renamed = Vec::with_capacity(80);
+        let mut contents = String::new();
+        File::open_read_to_cleared_string(path, &mut contents);
+
+        let mut cursor = Cursor::new(&contents);
+        let mut captures = [Capture::EMPTY; 3];
+
+        // First instance is the macro definition.
+        assert!(
+            cursor.find_ident("declare_with_version").is_some(),
+            "error reading deprecated lints"
+        );
+
+        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])),
+                    reason: parse_str_single_line(path.as_ref(), cursor.get_text(captures[2])),
+                    version: parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
+                });
             }
+        } else {
+            panic!("error reading deprecated lints");
         }
+
+        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])),
+                    new_name: parse_str_single_line(path.as_ref(), cursor.get_text(captures[2])),
+                    version: parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
+                });
+            }
+        } else {
+            panic!("error reading renamed lints");
+        }
+
+        deprecated.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
+        renamed.sort_by(|lhs, rhs| lhs.old_name.cmp(&rhs.old_name));
+        (deprecated, renamed)
     }
-    lints.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
-    lints
 }
 
 /// Reads the source files from the given root directory
@@ -116,72 +192,6 @@ fn parse_clippy_lint_decls(path: &Path, contents: &str, module: &str, lints: &mu
     }
 }
 
-#[must_use]
-pub fn read_deprecated_lints() -> (Vec<DeprecatedLint>, Vec<RenamedLint>) {
-    #[allow(clippy::enum_glob_use)]
-    use cursor::Pat::*;
-    #[rustfmt::skip]
-    static DECL_TOKENS: &[cursor::Pat<'_>] = &[
-        // #[clippy::version = "version"]
-        Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, CaptureLitStr, CloseBracket,
-        // ("first", "second"),
-        OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen, Comma,
-    ];
-    #[rustfmt::skip]
-    static DEPRECATED_TOKENS: &[cursor::Pat<'_>] = &[
-        // !{ DEPRECATED(DEPRECATED_VERSION) = [
-        Bang, OpenBrace, Ident("DEPRECATED"), OpenParen, Ident("DEPRECATED_VERSION"), CloseParen, Eq, OpenBracket,
-    ];
-    #[rustfmt::skip]
-    static RENAMED_TOKENS: &[cursor::Pat<'_>] = &[
-        // !{ RENAMED(RENAMED_VERSION) = [
-        Bang, OpenBrace, Ident("RENAMED"), OpenParen, Ident("RENAMED_VERSION"), CloseParen, Eq, OpenBracket,
-    ];
-
-    let path = "clippy_lints/src/deprecated_lints.rs";
-    let mut deprecated = Vec::with_capacity(30);
-    let mut renamed = Vec::with_capacity(80);
-    let mut contents = String::new();
-    File::open_read_to_cleared_string(path, &mut contents);
-
-    let mut cursor = Cursor::new(&contents);
-    let mut captures = [Capture::EMPTY; 3];
-
-    // First instance is the macro definition.
-    assert!(
-        cursor.find_ident("declare_with_version").is_some(),
-        "error reading deprecated lints"
-    );
-
-    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])),
-                reason: parse_str_single_line(path.as_ref(), cursor.get_text(captures[2])),
-                version: parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
-            });
-        }
-    } else {
-        panic!("error reading deprecated lints");
-    }
-
-    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])),
-                new_name: parse_str_single_line(path.as_ref(), cursor.get_text(captures[2])),
-                version: parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
-            });
-        }
-    } else {
-        panic!("error reading renamed lints");
-    }
-
-    deprecated.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
-    renamed.sort_by(|lhs, rhs| lhs.old_name.cmp(&rhs.old_name));
-    (deprecated, renamed)
-}
-
 /// Removes the line splices and surrounding quotes from a string literal
 fn parse_str_lit(s: &str) -> String {
     let (s, is_raw) = if let Some(s) = s.strip_prefix("r") {
diff --git a/clippy_dev/src/rename_lint.rs b/clippy_dev/src/rename_lint.rs
@@ -1,5 +1,5 @@
 use crate::parse::cursor::{self, Capture, Cursor};
-use crate::parse::{RenamedLint, find_lint_decls, read_deprecated_lints};
+use crate::parse::{ParseCx, RenamedLint};
 use crate::update_lints::generate_lint_files;
 use crate::utils::{
     ErrAction, FileUpdater, UpdateMode, UpdateStatus, Version, delete_dir_if_exists, delete_file_if_exists,
@@ -26,10 +26,10 @@ use std::path::Path;
 /// * If `old_name` doesn't name an existing lint.
 /// * If `old_name` names a deprecated or renamed lint.
 #[expect(clippy::too_many_lines)]
-pub fn rename(clippy_version: Version, old_name: &str, new_name: &str, uplift: bool) {
+pub fn rename<'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_name: &'cx str, new_name: &'cx str, uplift: bool) {
     let mut updater = FileUpdater::default();
-    let mut lints = find_lint_decls();
-    let (deprecated_lints, mut renamed_lints) = read_deprecated_lints();
+    let mut lints = cx.find_lint_decls();
+    let (deprecated_lints, mut renamed_lints) = cx.read_deprecated_lints();
 
     let Ok(lint_idx) = lints.binary_search_by(|x| x.name.as_str().cmp(old_name)) else {
         panic!("could not find lint `{old_name}`");
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
@@ -1,5 +1,5 @@
 use crate::parse::cursor::Cursor;
-use crate::parse::{DeprecatedLint, Lint, RenamedLint, find_lint_decls, read_deprecated_lints};
+use crate::parse::{DeprecatedLint, Lint, ParseCx, RenamedLint};
 use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, update_text_region_fn};
 use itertools::Itertools;
 use std::collections::HashSet;
@@ -21,9 +21,9 @@ const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.ht
 /// # Panics
 ///
 /// Panics if a file path could not read from or then written to
-pub fn update(update_mode: UpdateMode) {
-    let lints = find_lint_decls();
-    let (deprecated, renamed) = read_deprecated_lints();
+pub fn update(cx: ParseCx<'_>, update_mode: UpdateMode) {
+    let lints = cx.find_lint_decls();
+    let (deprecated, renamed) = cx.read_deprecated_lints();
     generate_lint_files(update_mode, &lints, &deprecated, &renamed);
 }
 
diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
@@ -1,5 +1,7 @@
 use core::fmt::{self, Display};
+use core::marker::PhantomData;
 use core::num::NonZero;
+use core::ops::{Deref, DerefMut};
 use core::range::Range;
 use core::str::FromStr;
 use std::ffi::OsStr;
@@ -10,6 +12,24 @@ use std::process::{self, Command, Stdio};
 use std::{env, thread};
 use walkdir::WalkDir;
 
+pub struct Scoped<'inner, 'outer: 'inner, T>(T, PhantomData<&'inner mut T>, PhantomData<&'outer mut ()>);
+impl<T> Scoped<'_, '_, T> {
+    pub fn new(value: T) -> Self {
+        Self(value, PhantomData, PhantomData)
+    }
+}
+impl<T> Deref for Scoped<'_, '_, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<T> DerefMut for Scoped<'_, '_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 #[derive(Clone, Copy)]
 pub enum ErrAction {
     Open,
