Avoid token clone in implicit string rule

.github/workflows/ci.yaml

@@ -117,7 +117,10 @@ jobs:
           tool: cargo-insta
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
-        run: cargo insta test --all --all-features --unreferenced reject
+        run: cargo insta test --all --exclude ruff_dev --all-features --unreferenced reject
+      - name: "Run dev tests"
+        # e.g. generating the schema — these should not run with all features enabled
+        run: cargo insta test -p ruff_dev --unreferenced reject
       # Check for broken links in the documentation.
       - run: cargo doc --all --no-deps
         env:

Cargo.toml

@@ -19,7 +19,6 @@ argfile = { version = "0.1.6" }
 assert_cmd = { version = "2.0.13" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "2.4.1" }
-bstr = { version = "1.9.0" }
 cachedir = { version = "0.3.1" }
 chrono = { version = "0.4.33", default-features = false, features = ["clock"] }
 clap = { version = "4.4.18", features = ["derive"] }
@@ -66,7 +65,7 @@ pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.4.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.78" }
-pyproject-toml = { version = "0.9.0" }
+pyproject-toml = { version = "0.8.2" }
 quick-junit = { version = "0.3.5" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }

crates/ruff/Cargo.toml

@@ -49,7 +49,6 @@ serde_json = { workspace = true }
 shellexpand = { workspace = true }
 strum = { workspace = true, features = [] }
 thiserror = { workspace = true }
-toml = { workspace = true }
 tracing = { workspace = true, features = ["log"] }
 walkdir = { workspace = true }
 wild = { workspace = true }

crates/ruff/src/args.rs

@@ -1,18 +1,12 @@
 use std::cmp::Ordering;
 use std::fmt::Formatter;
-use std::ops::Deref;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::Arc;
 
-use anyhow::bail;
-use clap::builder::{TypedValueParser, ValueParserFactory};
 use clap::{command, Parser};
 use colored::Colorize;
-use path_absolutize::path_dedot;
 use regex::Regex;
 use rustc_hash::FxHashMap;
-use toml;
 
 use ruff_linter::line_width::LineLength;
 use ruff_linter::logging::LogLevel;
@@ -25,7 +19,7 @@ use ruff_linter::{warn_user, RuleParser, RuleSelector, RuleSelectorParser};
 use ruff_source_file::{LineIndex, OneIndexed};
 use ruff_text_size::TextRange;
 use ruff_workspace::configuration::{Configuration, RuleSelection};
-use ruff_workspace::options::{Options, PycodestyleOptions};
+use ruff_workspace::options::PycodestyleOptions;
 use ruff_workspace::resolver::ConfigurationTransformer;
 
 #[derive(Debug, Parser)]
@@ -161,20 +155,10 @@ pub struct CheckCommand {
     preview: bool,
     #[clap(long, overrides_with("preview"), hide = true)]
     no_preview: bool,
-    /// Either a path to a TOML configuration file (`pyproject.toml` or `ruff.toml`),
-    /// or a TOML `<KEY> = <VALUE>` pair
-    /// (such as you might find in a `ruff.toml` configuration file)
-    /// overriding a specific configuration option.
-    /// Overrides of individual settings using this option always take precedence
-    /// over all configuration files, including configuration files that were also
-    /// specified using `--config`.
-    #[arg(
-        long,
-        action = clap::ArgAction::Append,
-        value_name = "CONFIG_OPTION",
-        value_parser = ConfigArgumentParser,
-    )]
-    pub config: Vec<SingleConfigArgument>,
+    /// Path to the `pyproject.toml` or `ruff.toml` file to use for
+    /// configuration.
+    #[arg(long, conflicts_with = "isolated")]
+    pub config: Option<PathBuf>,
     /// Comma-separated list of rule codes to enable (or ALL, to enable all rules).
     #[arg(
         long,
@@ -307,15 +291,7 @@ pub struct CheckCommand {
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
     pub no_cache: bool,
     /// Ignore all configuration files.
-    //
-    // Note: We can't mark this as conflicting with `--config` here
-    // as `--config` can be used for specifying configuration overrides
-    // as well as configuration files.
-    // Specifying a configuration file conflicts with `--isolated`;
-    // specifying a configuration override does not.
-    // If a user specifies `ruff check --isolated --config=ruff.toml`,
-    // we emit an error later on, after the initial parsing by clap.
-    #[arg(long, help_heading = "Miscellaneous")]
+    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
     pub isolated: bool,
     /// Path to the cache directory.
     #[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]
@@ -408,20 +384,9 @@ pub struct FormatCommand {
     /// difference between the current file and how the formatted file would look like.
     #[arg(long)]
     pub diff: bool,
-    /// Either a path to a TOML configuration file (`pyproject.toml` or `ruff.toml`),
-    /// or a TOML `<KEY> = <VALUE>` pair
-    /// (such as you might find in a `ruff.toml` configuration file)
-    /// overriding a specific configuration option.
-    /// Overrides of individual settings using this option always take precedence
-    /// over all configuration files, including configuration files that were also
-    /// specified using `--config`.
-    #[arg(
-        long,
-        action = clap::ArgAction::Append,
-        value_name = "CONFIG_OPTION",
-        value_parser = ConfigArgumentParser,
-    )]
-    pub config: Vec<SingleConfigArgument>,
+    /// Path to the `pyproject.toml` or `ruff.toml` file to use for configuration.
+    #[arg(long, conflicts_with = "isolated")]
+    pub config: Option<PathBuf>,
 
     /// Disable cache reads.
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
@@ -463,15 +428,7 @@ pub struct FormatCommand {
     #[arg(long, help_heading = "Format configuration")]
     pub line_length: Option<LineLength>,
     /// Ignore all configuration files.
-    //
-    // Note: We can't mark this as conflicting with `--config` here
-    // as `--config` can be used for specifying configuration overrides
-    // as well as configuration files.
-    // Specifying a configuration file conflicts with `--isolated`;
-    // specifying a configuration override does not.
-    // If a user specifies `ruff check --isolated --config=ruff.toml`,
-    // we emit an error later on, after the initial parsing by clap.
-    #[arg(long, help_heading = "Miscellaneous")]
+    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
     pub isolated: bool,
     /// The name of the file when passing it through stdin.
     #[arg(long, help_heading = "Miscellaneous")]
@@ -558,181 +515,101 @@ impl From<&LogLevelArgs> for LogLevel {
     }
 }
 
-/// Configuration-related arguments passed via the CLI.
-#[derive(Default)]
-pub struct ConfigArguments {
-    /// Path to a pyproject.toml or ruff.toml configuration file (etc.).
-    /// Either 0 or 1 configuration file paths may be provided on the command line.
-    config_file: Option<PathBuf>,
-    /// Overrides provided via the `--config "KEY=VALUE"` option.
-    /// An arbitrary number of these overrides may be provided on the command line.
-    /// These overrides take precedence over all configuration files,
-    /// even configuration files that were also specified using `--config`.
-    overrides: Configuration,
-    /// Overrides provided via dedicated flags such as `--line-length` etc.
-    /// These overrides take precedence over all configuration files,
-    /// and also over all overrides specified using any `--config "KEY=VALUE"` flags.
-    per_flag_overrides: ExplicitConfigOverrides,
-}
-
-impl ConfigArguments {
-    pub fn config_file(&self) -> Option<&Path> {
-        self.config_file.as_deref()
-    }
-
-    fn from_cli_arguments(
-        config_options: Vec<SingleConfigArgument>,
-        per_flag_overrides: ExplicitConfigOverrides,
-        isolated: bool,
-    ) -> anyhow::Result<Self> {
-        let mut new = Self {
-            per_flag_overrides,
-            ..Self::default()
-        };
-
-        for option in config_options {
-            match option {
-                SingleConfigArgument::SettingsOverride(overridden_option) => {
-                    let overridden_option = Arc::try_unwrap(overridden_option)
-                        .unwrap_or_else(|option| option.deref().clone());
-                    new.overrides = new.overrides.combine(Configuration::from_options(
-                        overridden_option,
-                        None,
-                        &path_dedot::CWD,
-                    )?);
-                }
-                SingleConfigArgument::FilePath(path) => {
-                    if isolated {
-                        bail!(
-                            "\
-The argument `--config={}` cannot be used with `--isolated`
-
-  tip: You cannot specify a configuration file and also specify `--isolated`,
-       as `--isolated` causes ruff to ignore all configuration files.
-       For more information, try `--help`.
-",
-                            path.display()
-                        );
-                    }
-                    if let Some(ref config_file) = new.config_file {
-                        let (first, second) = (config_file.display(), path.display());
-                        bail!(
-                            "\
-You cannot specify more than one configuration file on the command line.
-
-  tip: remove either `--config={first}` or `--config={second}`.
-       For more information, try `--help`.
-"
-                        );
-                    }
-                    new.config_file = Some(path);
-                }
-            }
-        }
-        Ok(new)
-    }
-}
-
-impl ConfigurationTransformer for ConfigArguments {
-    fn transform(&self, config: Configuration) -> Configuration {
-        let with_config_overrides = self.overrides.clone().combine(config);
-        self.per_flag_overrides.transform(with_config_overrides)
-    }
-}
-
 impl CheckCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> anyhow::Result<(CheckArguments, ConfigArguments)> {
-        let check_arguments = CheckArguments {
-            add_noqa: self.add_noqa,
-            diff: self.diff,
-            ecosystem_ci: self.ecosystem_ci,
-            exit_non_zero_on_fix: self.exit_non_zero_on_fix,
-            exit_zero: self.exit_zero,
-            files: self.files,
-            ignore_noqa: self.ignore_noqa,
-            isolated: self.isolated,
-            no_cache: self.no_cache,
-            output_file: self.output_file,
-            show_files: self.show_files,
-            show_settings: self.show_settings,
-            statistics: self.statistics,
-            stdin_filename: self.stdin_filename,
-            watch: self.watch,
-        };
-
-        let cli_overrides = ExplicitConfigOverrides {
-            dummy_variable_rgx: self.dummy_variable_rgx,
-            exclude: self.exclude,
-            extend_exclude: self.extend_exclude,
-            extend_fixable: self.extend_fixable,
-            extend_ignore: self.extend_ignore,
-            extend_per_file_ignores: self.extend_per_file_ignores,
-            extend_select: self.extend_select,
-            extend_unfixable: self.extend_unfixable,
-            fixable: self.fixable,
-            ignore: self.ignore,
-            line_length: self.line_length,
-            per_file_ignores: self.per_file_ignores,
-            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
-            select: self.select,
-            target_version: self.target_version,
-            unfixable: self.unfixable,
-            // TODO(charlie): Included in `pyproject.toml`, but not inherited.
-            cache_dir: self.cache_dir,
-            fix: resolve_bool_arg(self.fix, self.no_fix),
-            fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
-            unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
-                .map(UnsafeFixes::from),
-            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-            output_format: resolve_output_format(
-                self.output_format,
-                resolve_bool_arg(self.show_source, self.no_show_source),
-                resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
-            ),
-            show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
-            extension: self.extension,
-        };
-
-        let config_args =
-            ConfigArguments::from_cli_arguments(self.config, cli_overrides, self.isolated)?;
-        Ok((check_arguments, config_args))
+    pub fn partition(self) -> (CheckArguments, CliOverrides) {
+        (
+            CheckArguments {
+                add_noqa: self.add_noqa,
+                config: self.config,
+                diff: self.diff,
+                ecosystem_ci: self.ecosystem_ci,
+                exit_non_zero_on_fix: self.exit_non_zero_on_fix,
+                exit_zero: self.exit_zero,
+                files: self.files,
+                ignore_noqa: self.ignore_noqa,
+                isolated: self.isolated,
+                no_cache: self.no_cache,
+                output_file: self.output_file,
+                show_files: self.show_files,
+                show_settings: self.show_settings,
+                statistics: self.statistics,
+                stdin_filename: self.stdin_filename,
+                watch: self.watch,
+            },
+            CliOverrides {
+                dummy_variable_rgx: self.dummy_variable_rgx,
+                exclude: self.exclude,
+                extend_exclude: self.extend_exclude,
+                extend_fixable: self.extend_fixable,
+                extend_ignore: self.extend_ignore,
+                extend_per_file_ignores: self.extend_per_file_ignores,
+                extend_select: self.extend_select,
+                extend_unfixable: self.extend_unfixable,
+                fixable: self.fixable,
+                ignore: self.ignore,
+                line_length: self.line_length,
+                per_file_ignores: self.per_file_ignores,
+                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+                respect_gitignore: resolve_bool_arg(
+                    self.respect_gitignore,
+                    self.no_respect_gitignore,
+                ),
+                select: self.select,
+                target_version: self.target_version,
+                unfixable: self.unfixable,
+                // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+                cache_dir: self.cache_dir,
+                fix: resolve_bool_arg(self.fix, self.no_fix),
+                fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
+                unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
+                    .map(UnsafeFixes::from),
+                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+                output_format: resolve_output_format(
+                    self.output_format,
+                    resolve_bool_arg(self.show_source, self.no_show_source),
+                    resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
+                ),
+                show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
+                extension: self.extension,
+            },
+        )
     }
 }
 
 impl FormatCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> anyhow::Result<(FormatArguments, ConfigArguments)> {
-        let format_arguments = FormatArguments {
-            check: self.check,
-            diff: self.diff,
-            files: self.files,
-            isolated: self.isolated,
-            no_cache: self.no_cache,
-            stdin_filename: self.stdin_filename,
-            range: self.range,
-        };
+    pub fn partition(self) -> (FormatArguments, CliOverrides) {
+        (
+            FormatArguments {
+                check: self.check,
+                diff: self.diff,
+                config: self.config,
+                files: self.files,
+                isolated: self.isolated,
+                no_cache: self.no_cache,
+                stdin_filename: self.stdin_filename,
+                range: self.range,
+            },
+            CliOverrides {
+                line_length: self.line_length,
+                respect_gitignore: resolve_bool_arg(
+                    self.respect_gitignore,
+                    self.no_respect_gitignore,
+                ),
+                exclude: self.exclude,
+                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+                target_version: self.target_version,
+                cache_dir: self.cache_dir,
+                extension: self.extension,
 
-        let cli_overrides = ExplicitConfigOverrides {
-            line_length: self.line_length,
-            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
-            exclude: self.exclude,
-            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-            target_version: self.target_version,
-            cache_dir: self.cache_dir,
-            extension: self.extension,
-
-            // Unsupported on the formatter CLI, but required on `Overrides`.
-            ..ExplicitConfigOverrides::default()
-        };
-
-        let config_args =
-            ConfigArguments::from_cli_arguments(self.config, cli_overrides, self.isolated)?;
-        Ok((format_arguments, config_args))
+                // Unsupported on the formatter CLI, but required on `Overrides`.
+                ..CliOverrides::default()
+            },
+        )
     }
 }
 
@@ -745,154 +622,6 @@ fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
     }
 }
 
-#[derive(Debug)]
-enum TomlParseFailureKind {
-    SyntaxError,
-    UnknownOption,
-}
-
-impl std::fmt::Display for TomlParseFailureKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let display = match self {
-            Self::SyntaxError => "The supplied argument is not valid TOML",
-            Self::UnknownOption => {
-                "Could not parse the supplied argument as a `ruff.toml` configuration option"
-            }
-        };
-        write!(f, "{display}")
-    }
-}
-
-#[derive(Debug)]
-struct TomlParseFailure {
-    kind: TomlParseFailureKind,
-    underlying_error: toml::de::Error,
-}
-
-impl std::fmt::Display for TomlParseFailure {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let TomlParseFailure {
-            kind,
-            underlying_error,
-        } = self;
-        let display = format!("{kind}:\n\n{underlying_error}");
-        write!(f, "{}", display.trim_end())
-    }
-}
-
-/// Enumeration to represent a single `--config` argument
-/// passed via the CLI.
-///
-/// Using the `--config` flag, users may pass 0 or 1 paths
-/// to configuration files and an arbitrary number of
-/// "inline TOML" overrides for specific settings.
-///
-/// For example:
-///
-/// ```sh
-/// ruff check --config "path/to/ruff.toml" --config "extend-select=['E501', 'F841']" --config "lint.per-file-ignores = {'some_file.py' = ['F841']}"
-/// ```
-#[derive(Clone, Debug)]
-pub enum SingleConfigArgument {
-    FilePath(PathBuf),
-    SettingsOverride(Arc<Options>),
-}
-
-#[derive(Clone)]
-pub struct ConfigArgumentParser;
-
-impl ValueParserFactory for SingleConfigArgument {
-    type Parser = ConfigArgumentParser;
-
-    fn value_parser() -> Self::Parser {
-        ConfigArgumentParser
-    }
-}
-
-impl TypedValueParser for ConfigArgumentParser {
-    type Value = SingleConfigArgument;
-
-    fn parse_ref(
-        &self,
-        cmd: &clap::Command,
-        arg: Option<&clap::Arg>,
-        value: &std::ffi::OsStr,
-    ) -> Result<Self::Value, clap::Error> {
-        let path_to_config_file = PathBuf::from(value);
-        if path_to_config_file.exists() {
-            return Ok(SingleConfigArgument::FilePath(path_to_config_file));
-        }
-
-        let value = value
-            .to_str()
-            .ok_or_else(|| clap::Error::new(clap::error::ErrorKind::InvalidUtf8))?;
-
-        let toml_parse_error = match toml::Table::from_str(value) {
-            Ok(table) => match table.try_into() {
-                Ok(option) => return Ok(SingleConfigArgument::SettingsOverride(Arc::new(option))),
-                Err(underlying_error) => TomlParseFailure {
-                    kind: TomlParseFailureKind::UnknownOption,
-                    underlying_error,
-                },
-            },
-            Err(underlying_error) => TomlParseFailure {
-                kind: TomlParseFailureKind::SyntaxError,
-                underlying_error,
-            },
-        };
-
-        let mut new_error = clap::Error::new(clap::error::ErrorKind::ValueValidation).with_cmd(cmd);
-        if let Some(arg) = arg {
-            new_error.insert(
-                clap::error::ContextKind::InvalidArg,
-                clap::error::ContextValue::String(arg.to_string()),
-            );
-        }
-        new_error.insert(
-            clap::error::ContextKind::InvalidValue,
-            clap::error::ContextValue::String(value.to_string()),
-        );
-
-        // small hack so that multiline tips
-        // have the same indent on the left-hand side:
-        let tip_indent = " ".repeat("  tip: ".len());
-
-        let mut tip = format!(
-            "\
-A `--config` flag must either be a path to a `.toml` configuration file
-{tip_indent}or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-{tip_indent}option"
-        );
-
-        // Here we do some heuristics to try to figure out whether
-        // the user was trying to pass in a path to a configuration file
-        // or some inline TOML.
-        // We want to display the most helpful error to the user as possible.
-        if std::path::Path::new(value)
-            .extension()
-            .map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
-        {
-            if !value.contains('=') {
-                tip.push_str(&format!(
-                    "
-
-It looks like you were trying to pass a path to a configuration file.
-The path `{value}` does not exist"
-                ));
-            }
-        } else if value.contains('=') {
-            tip.push_str(&format!("\n\n{toml_parse_error}"));
-        }
-
-        new_error.insert(
-            clap::error::ContextKind::Suggested,
-            clap::error::ContextValue::StyledStrs(vec![tip.into()]),
-        );
-
-        Err(new_error)
-    }
-}
-
 fn resolve_output_format(
     output_format: Option<SerializationFormat>,
     show_sources: Option<bool>,
@@ -935,6 +664,7 @@ fn resolve_output_format(
 #[allow(clippy::struct_excessive_bools)]
 pub struct CheckArguments {
     pub add_noqa: bool,
+    pub config: Option<PathBuf>,
     pub diff: bool,
     pub ecosystem_ci: bool,
     pub exit_non_zero_on_fix: bool,
@@ -958,6 +688,7 @@ pub struct FormatArguments {
     pub check: bool,
     pub no_cache: bool,
     pub diff: bool,
+    pub config: Option<PathBuf>,
     pub files: Vec<PathBuf>,
     pub isolated: bool,
     pub stdin_filename: Option<PathBuf>,
@@ -1153,40 +884,39 @@ impl LineColumnParseError {
     }
 }
 
-/// Configuration overrides provided via dedicated CLI flags:
-/// `--line-length`, `--respect-gitignore`, etc.
+/// CLI settings that function as configuration overrides.
 #[derive(Clone, Default)]
 #[allow(clippy::struct_excessive_bools)]
-struct ExplicitConfigOverrides {
-    dummy_variable_rgx: Option<Regex>,
-    exclude: Option<Vec<FilePattern>>,
-    extend_exclude: Option<Vec<FilePattern>>,
-    extend_fixable: Option<Vec<RuleSelector>>,
-    extend_ignore: Option<Vec<RuleSelector>>,
-    extend_select: Option<Vec<RuleSelector>>,
-    extend_unfixable: Option<Vec<RuleSelector>>,
-    fixable: Option<Vec<RuleSelector>>,
-    ignore: Option<Vec<RuleSelector>>,
-    line_length: Option<LineLength>,
-    per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    preview: Option<PreviewMode>,
-    respect_gitignore: Option<bool>,
-    select: Option<Vec<RuleSelector>>,
-    target_version: Option<PythonVersion>,
-    unfixable: Option<Vec<RuleSelector>>,
+pub struct CliOverrides {
+    pub dummy_variable_rgx: Option<Regex>,
+    pub exclude: Option<Vec<FilePattern>>,
+    pub extend_exclude: Option<Vec<FilePattern>>,
+    pub extend_fixable: Option<Vec<RuleSelector>>,
+    pub extend_ignore: Option<Vec<RuleSelector>>,
+    pub extend_select: Option<Vec<RuleSelector>>,
+    pub extend_unfixable: Option<Vec<RuleSelector>>,
+    pub fixable: Option<Vec<RuleSelector>>,
+    pub ignore: Option<Vec<RuleSelector>>,
+    pub line_length: Option<LineLength>,
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    pub extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    pub preview: Option<PreviewMode>,
+    pub respect_gitignore: Option<bool>,
+    pub select: Option<Vec<RuleSelector>>,
+    pub target_version: Option<PythonVersion>,
+    pub unfixable: Option<Vec<RuleSelector>>,
     // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
-    cache_dir: Option<PathBuf>,
-    fix: Option<bool>,
-    fix_only: Option<bool>,
-    unsafe_fixes: Option<UnsafeFixes>,
-    force_exclude: Option<bool>,
-    output_format: Option<SerializationFormat>,
-    show_fixes: Option<bool>,
-    extension: Option<Vec<ExtensionPair>>,
+    pub cache_dir: Option<PathBuf>,
+    pub fix: Option<bool>,
+    pub fix_only: Option<bool>,
+    pub unsafe_fixes: Option<UnsafeFixes>,
+    pub force_exclude: Option<bool>,
+    pub output_format: Option<SerializationFormat>,
+    pub show_fixes: Option<bool>,
+    pub extension: Option<Vec<ExtensionPair>>,
 }
 
-impl ConfigurationTransformer for ExplicitConfigOverrides {
+impl ConfigurationTransformer for CliOverrides {
     fn transform(&self, mut config: Configuration) -> Configuration {
         if let Some(cache_dir) = &self.cache_dir {
             config.cache_dir = Some(cache_dir.clone());

crates/ruff/src/commands/add_noqa.rs

@@ -12,17 +12,17 @@ use ruff_linter::warn_user_once;
 use ruff_python_ast::{PySourceType, SourceType};
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 
 /// Add `noqa` directives to a collection of files.
 pub(crate) fn add_noqa(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
 ) -> Result<usize> {
     // Collect all the files to check.
     let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
     let duration = start.elapsed();
     debug!("Identified files to lint in: {:?}", duration);
 

crates/ruff/src/commands/check.rs

@@ -24,7 +24,7 @@ use ruff_workspace::resolver::{
     match_exclusion, python_files_in_path, PyprojectConfig, ResolvedFile,
 };
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 use crate::cache::{Cache, PackageCacheMap, PackageCaches};
 use crate::diagnostics::Diagnostics;
 use crate::panic::catch_unwind;
@@ -34,7 +34,7 @@ use crate::panic::catch_unwind;
 pub(crate) fn check(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
     cache: flags::Cache,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
@@ -42,7 +42,7 @@ pub(crate) fn check(
 ) -> Result<Diagnostics> {
     // Collect all the Python files to check.
     let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
     debug!("Identified files to lint in: {:?}", start.elapsed());
 
     if paths.is_empty() {
@@ -233,7 +233,7 @@ mod test {
     use ruff_workspace::resolver::{PyprojectConfig, PyprojectDiscoveryStrategy};
     use ruff_workspace::Settings;
 
-    use crate::args::ConfigArguments;
+    use crate::args::CliOverrides;
 
     use super::check;
 
@@ -272,7 +272,7 @@ mod test {
             // Notebooks are not included by default
             &[tempdir.path().to_path_buf(), notebook],
             &pyproject_config,
-            &ConfigArguments::default(),
+            &CliOverrides::default(),
             flags::Cache::Disabled,
             flags::Noqa::Disabled,
             flags::FixMode::Generate,

crates/ruff/src/commands/check_stdin.rs

@@ -6,7 +6,7 @@ use ruff_linter::packaging;
 use ruff_linter::settings::flags;
 use ruff_workspace::resolver::{match_exclusion, python_file_at_path, PyprojectConfig, Resolver};
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 use crate::diagnostics::{lint_stdin, Diagnostics};
 use crate::stdin::{parrot_stdin, read_from_stdin};
 
@@ -14,7 +14,7 @@ use crate::stdin::{parrot_stdin, read_from_stdin};
 pub(crate) fn check_stdin(
     filename: Option<&Path>,
     pyproject_config: &PyprojectConfig,
-    overrides: &ConfigArguments,
+    overrides: &CliOverrides,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {

crates/ruff/src/commands/format.rs

@@ -29,7 +29,7 @@ use ruff_text_size::{TextLen, TextRange, TextSize};
 use ruff_workspace::resolver::{match_exclusion, python_files_in_path, ResolvedFile, Resolver};
 use ruff_workspace::FormatterSettings;
 
-use crate::args::{ConfigArguments, FormatArguments, FormatRange};
+use crate::args::{CliOverrides, FormatArguments, FormatRange};
 use crate::cache::{Cache, FileCacheKey, PackageCacheMap, PackageCaches};
 use crate::panic::{catch_unwind, PanicError};
 use crate::resolve::resolve;
@@ -60,17 +60,18 @@ impl FormatMode {
 /// Format a set of files, and return the exit status.
 pub(crate) fn format(
     cli: FormatArguments,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
     log_level: LogLevel,
 ) -> Result<ExitStatus> {
     let pyproject_config = resolve(
         cli.isolated,
-        config_arguments,
+        cli.config.as_deref(),
+        overrides,
         cli.stdin_filename.as_deref(),
     )?;
     let mode = FormatMode::from_cli(&cli);
     let files = resolve_default_files(cli.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
+    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, overrides)?;
 
     if paths.is_empty() {
         warn_user_once!("No Python files found under the given path(s)");

crates/ruff/src/commands/format_stdin.rs

@@ -9,7 +9,7 @@ use ruff_python_ast::{PySourceType, SourceType};
 use ruff_workspace::resolver::{match_exclusion, python_file_at_path, Resolver};
 use ruff_workspace::FormatterSettings;
 
-use crate::args::{ConfigArguments, FormatArguments, FormatRange};
+use crate::args::{CliOverrides, FormatArguments, FormatRange};
 use crate::commands::format::{
     format_source, warn_incompatible_formatter_settings, FormatCommandError, FormatMode,
     FormatResult, FormattedSource,
@@ -19,13 +19,11 @@ use crate::stdin::{parrot_stdin, read_from_stdin};
 use crate::ExitStatus;
 
 /// Run the formatter over a single file, read from `stdin`.
-pub(crate) fn format_stdin(
-    cli: &FormatArguments,
-    config_arguments: &ConfigArguments,
-) -> Result<ExitStatus> {
+pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> Result<ExitStatus> {
     let pyproject_config = resolve(
         cli.isolated,
-        config_arguments,
+        cli.config.as_deref(),
+        overrides,
         cli.stdin_filename.as_deref(),
     )?;
 
@@ -36,7 +34,7 @@ pub(crate) fn format_stdin(
 
     if resolver.force_exclude() {
         if let Some(filename) = cli.stdin_filename.as_deref() {
-            if !python_file_at_path(filename, &mut resolver, config_arguments)? {
+            if !python_file_at_path(filename, &mut resolver, overrides)? {
                 if mode.is_write() {
                     parrot_stdin()?;
                 }

crates/ruff/src/commands/show_files.rs

@@ -7,17 +7,17 @@ use itertools::Itertools;
 use ruff_linter::warn_user_once;
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 
 /// Show the list of files to be checked based on current settings.
 pub(crate) fn show_files(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
     writer: &mut impl Write,
 ) -> Result<()> {
     // Collect all files in the hierarchy.
-    let (paths, _resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
+    let (paths, _resolver) = python_files_in_path(files, pyproject_config, overrides)?;
 
     if paths.is_empty() {
         warn_user_once!("No Python files found under the given path(s)");

crates/ruff/src/commands/show_settings.rs

@@ -6,17 +6,17 @@ use itertools::Itertools;
 
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 
 /// Print the user-facing configuration settings.
 pub(crate) fn show_settings(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
     writer: &mut impl Write,
 ) -> Result<()> {
     // Collect all files in the hierarchy.
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
 
     // Print the list of files.
     let Some(path) = paths
@@ -31,9 +31,9 @@ pub(crate) fn show_settings(
 
     let settings = resolver.resolve(&path);
 
-    writeln!(writer, "Resolved settings for: \"{}\"", path.display())?;
+    writeln!(writer, "Resolved settings for: {path:?}")?;
     if let Some(settings_path) = pyproject_config.path.as_ref() {
-        writeln!(writer, "Settings path: \"{}\"", settings_path.display())?;
+        writeln!(writer, "Settings path: {settings_path:?}")?;
     }
     write!(writer, "{settings}")?;
 

crates/ruff/src/lib.rs

@@ -204,23 +204,24 @@ pub fn run(
 }
 
 fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition()?;
+    let (cli, overrides) = args.partition();
 
     if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
-        commands::format_stdin::format_stdin(&cli, &config_arguments)
+        commands::format_stdin::format_stdin(&cli, &overrides)
     } else {
-        commands::format::format(cli, &config_arguments, log_level)
+        commands::format::format(cli, &overrides, log_level)
     }
 }
 
 pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition()?;
+    let (cli, overrides) = args.partition();
 
     // Construct the "default" settings. These are used when no `pyproject.toml`
     // files are present, or files are injected from outside of the hierarchy.
     let pyproject_config = resolve::resolve(
         cli.isolated,
-        &config_arguments,
+        cli.config.as_deref(),
+        &overrides,
         cli.stdin_filename.as_deref(),
     )?;
 
@@ -238,21 +239,11 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
     let files = resolve_default_files(cli.files, is_stdin);
 
     if cli.show_settings {
-        commands::show_settings::show_settings(
-            &files,
-            &pyproject_config,
-            &config_arguments,
-            &mut writer,
-        )?;
+        commands::show_settings::show_settings(&files, &pyproject_config, &overrides, &mut writer)?;
         return Ok(ExitStatus::Success);
     }
     if cli.show_files {
-        commands::show_files::show_files(
-            &files,
-            &pyproject_config,
-            &config_arguments,
-            &mut writer,
-        )?;
+        commands::show_files::show_files(&files, &pyproject_config, &overrides, &mut writer)?;
         return Ok(ExitStatus::Success);
     }
 
@@ -311,8 +302,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         if !fix_mode.is_generate() {
             warn_user!("--fix is incompatible with --add-noqa.");
         }
-        let modifications =
-            commands::add_noqa::add_noqa(&files, &pyproject_config, &config_arguments)?;
+        let modifications = commands::add_noqa::add_noqa(&files, &pyproject_config, &overrides)?;
         if modifications > 0 && log_level >= LogLevel::Default {
             let s = if modifications == 1 { "" } else { "s" };
             #[allow(clippy::print_stderr)]
@@ -362,7 +352,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         let messages = commands::check::check(
             &files,
             &pyproject_config,
-            &config_arguments,
+            &overrides,
             cache.into(),
             noqa.into(),
             fix_mode,
@@ -384,7 +374,8 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     if matches!(change_kind, ChangeKind::Configuration) {
                         pyproject_config = resolve::resolve(
                             cli.isolated,
-                            &config_arguments,
+                            cli.config.as_deref(),
+                            &overrides,
                             cli.stdin_filename.as_deref(),
                         )?;
                     }
@@ -394,7 +385,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     let messages = commands::check::check(
                         &files,
                         &pyproject_config,
-                        &config_arguments,
+                        &overrides,
                         cache.into(),
                         noqa.into(),
                         fix_mode,
@@ -411,7 +402,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check_stdin::check_stdin(
                 cli.stdin_filename.map(fs::normalize_path).as_deref(),
                 &pyproject_config,
-                &config_arguments,
+                &overrides,
                 noqa.into(),
                 fix_mode,
             )?
@@ -419,7 +410,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check::check(
                 &files,
                 &pyproject_config,
-                &config_arguments,
+                &overrides,
                 cache.into(),
                 noqa.into(),
                 fix_mode,

crates/ruff/src/resolve.rs

@@ -11,18 +11,19 @@ use ruff_workspace::resolver::{
     Relativity,
 };
 
-use crate::args::ConfigArguments;
+use crate::args::CliOverrides;
 
 /// Resolve the relevant settings strategy and defaults for the current
 /// invocation.
 pub fn resolve(
     isolated: bool,
-    config_arguments: &ConfigArguments,
+    config: Option<&Path>,
+    overrides: &CliOverrides,
     stdin_filename: Option<&Path>,
 ) -> Result<PyprojectConfig> {
     // First priority: if we're running in isolated mode, use the default settings.
     if isolated {
-        let config = config_arguments.transform(Configuration::default());
+        let config = overrides.transform(Configuration::default());
         let settings = config.into_settings(&path_dedot::CWD)?;
         debug!("Isolated mode, not reading any pyproject.toml");
         return Ok(PyprojectConfig::new(
@@ -35,13 +36,12 @@ pub fn resolve(
     // Second priority: the user specified a `pyproject.toml` file. Use that
     // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
     // current working directory. (This matches ESLint's behavior.)
-    if let Some(pyproject) = config_arguments
-        .config_file()
+    if let Some(pyproject) = config
         .map(|config| config.display().to_string())
         .map(|config| shellexpand::full(&config).map(|config| PathBuf::from(config.as_ref())))
         .transpose()?
     {
-        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, config_arguments)?;
+        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
         debug!(
             "Using user-specified configuration file at: {}",
             pyproject.display()
@@ -67,7 +67,7 @@ pub fn resolve(
             "Using configuration file (via parent) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Parent, config_arguments)?;
+        let settings = resolve_root_settings(&pyproject, Relativity::Parent, overrides)?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -84,7 +84,7 @@ pub fn resolve(
             "Using configuration file (via cwd) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, config_arguments)?;
+        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -97,7 +97,7 @@ pub fn resolve(
     // "closest" `pyproject.toml` file for every Python file later on, so these act
     // as the "default" settings.)
     debug!("Using Ruff default settings");
-    let config = config_arguments.transform(Configuration::default());
+    let config = overrides.transform(Configuration::default());
     let settings = config.into_settings(&path_dedot::CWD)?;
     Ok(PyprojectConfig::new(
         PyprojectDiscoveryStrategy::Hierarchical,

crates/ruff/tests/format.rs

@@ -90,179 +90,6 @@ fn format_warn_stdin_filename_with_files() {
     "###);
 }
 
-#[test]
-fn nonexistent_config_file() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(["format", "--config", "foo.toml", "."]), @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'foo.toml' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    It looks like you were trying to pass a path to a configuration file.
-    The path `foo.toml` does not exist
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn config_override_rejected_if_invalid_toml() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(["format", "--config", "foo = bar", "."]), @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    The supplied argument is not valid TOML:
-
-    TOML parse error at line 1, column 7
-      |
-    1 | foo = bar
-      |       ^
-    invalid string
-    expected `"`, `'`
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn too_many_config_files() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_dot_toml = tempdir.path().join("ruff.toml");
-    let ruff2_dot_toml = tempdir.path().join("ruff2.toml");
-    fs::File::create(&ruff_dot_toml)?;
-    fs::File::create(&ruff2_dot_toml)?;
-    let expected_stderr = format!(
-        "\
-ruff failed
-  Cause: You cannot specify more than one configuration file on the command line.
-
-  tip: remove either `--config={}` or `--config={}`.
-       For more information, try `--help`.
-
-",
-        ruff_dot_toml.display(),
-        ruff2_dot_toml.display(),
-    );
-    let cmd = Command::new(get_cargo_bin(BIN_NAME))
-        .arg("format")
-        .arg("--config")
-        .arg(&ruff_dot_toml)
-        .arg("--config")
-        .arg(&ruff2_dot_toml)
-        .arg(".")
-        .output()?;
-    let stderr = std::str::from_utf8(&cmd.stderr)?;
-    assert_eq!(stderr, expected_stderr);
-    Ok(())
-}
-
-#[test]
-fn config_file_and_isolated() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_dot_toml = tempdir.path().join("ruff.toml");
-    fs::File::create(&ruff_dot_toml)?;
-    let expected_stderr = format!(
-        "\
-ruff failed
-  Cause: The argument `--config={}` cannot be used with `--isolated`
-
-  tip: You cannot specify a configuration file and also specify `--isolated`,
-       as `--isolated` causes ruff to ignore all configuration files.
-       For more information, try `--help`.
-
-",
-        ruff_dot_toml.display(),
-    );
-    let cmd = Command::new(get_cargo_bin(BIN_NAME))
-        .arg("format")
-        .arg("--config")
-        .arg(&ruff_dot_toml)
-        .arg("--isolated")
-        .arg(".")
-        .output()?;
-    let stderr = std::str::from_utf8(&cmd.stderr)?;
-    assert_eq!(stderr, expected_stderr);
-    Ok(())
-}
-
-#[test]
-fn config_override_via_cli() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(&ruff_toml, "line-length = 100")?;
-    let fixture = r#"
-def foo():
-    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
-
-    "#;
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .arg("format")
-        .arg("--config")
-        .arg(&ruff_toml)
-        // This overrides the long line length set in the config file
-        .args(["--config", "line-length=80"])
-        .arg("-")
-        .pass_stdin(fixture), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    def foo():
-        print(
-            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string"
-        )
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn config_doubly_overridden_via_cli() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(&ruff_toml, "line-length = 70")?;
-    let fixture = r#"
-def foo():
-    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
-
-    "#;
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .arg("format")
-        .arg("--config")
-        .arg(&ruff_toml)
-        // This overrides the long line length set in the config file...
-        .args(["--config", "line-length=80"])
-        // ...but this overrides them both:
-        .args(["--line-length", "100"])
-        .arg("-")
-        .pass_stdin(fixture), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    def foo():
-        print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
 #[test]
 fn format_options() -> Result<()> {
     let tempdir = TempDir::new()?;

crates/ruff/tests/lint.rs

@@ -510,341 +510,6 @@ ignore = ["D203", "D212"]
     Ok(())
 }
 
-#[test]
-fn nonexistent_config_file() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .args(["--config", "foo.toml", "."]), @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'foo.toml' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    It looks like you were trying to pass a path to a configuration file.
-    The path `foo.toml` does not exist
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn config_override_rejected_if_invalid_toml() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .args(["--config", "foo = bar", "."]), @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    The supplied argument is not valid TOML:
-
-    TOML parse error at line 1, column 7
-      |
-    1 | foo = bar
-      |       ^
-    invalid string
-    expected `"`, `'`
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn too_many_config_files() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_dot_toml = tempdir.path().join("ruff.toml");
-    let ruff2_dot_toml = tempdir.path().join("ruff2.toml");
-    fs::File::create(&ruff_dot_toml)?;
-    fs::File::create(&ruff2_dot_toml)?;
-    insta::with_settings!({
-        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
-    }, {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .arg("--config")
-        .arg(&ruff_dot_toml)
-        .arg("--config")
-        .arg(&ruff2_dot_toml)
-        .arg("."), @r###"
-        success: false
-        exit_code: 2
-        ----- stdout -----
-
-        ----- stderr -----
-        ruff failed
-          Cause: You cannot specify more than one configuration file on the command line.
-
-          tip: remove either `--config=[TMP]/ruff.toml` or `--config=[TMP]/ruff2.toml`.
-               For more information, try `--help`.
-
-        "###);
-    });
-    Ok(())
-}
-
-#[test]
-fn config_file_and_isolated() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_dot_toml = tempdir.path().join("ruff.toml");
-    fs::File::create(&ruff_dot_toml)?;
-    insta::with_settings!({
-        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
-    }, {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .arg("--config")
-        .arg(&ruff_dot_toml)
-        .arg("--isolated")
-        .arg("."), @r###"
-        success: false
-        exit_code: 2
-        ----- stdout -----
-
-        ----- stderr -----
-        ruff failed
-          Cause: The argument `--config=[TMP]/ruff.toml` cannot be used with `--isolated`
-
-          tip: You cannot specify a configuration file and also specify `--isolated`,
-               as `--isolated` causes ruff to ignore all configuration files.
-               For more information, try `--help`.
-
-        "###);
-    });
-    Ok(())
-}
-
-#[test]
-fn config_override_via_cli() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-line-length = 100
-
-[lint]
-select = ["I"]
-
-[lint.isort]
-combine-as-imports = true
-        "#,
-    )?;
-    let fixture = r#"
-from foo import (
-    aaaaaaaaaaaaaaaaaaa,
-    bbbbbbbbbbb as bbbbbbbbbbbbbbbb,
-    cccccccccccccccc,
-    ddddddddddd as ddddddddddddd,
-    eeeeeeeeeeeeeee,
-    ffffffffffff as ffffffffffffff,
-    ggggggggggggg,
-    hhhhhhh as hhhhhhhhhhh,
-    iiiiiiiiiiiiii,
-    jjjjjjjjjjjjj as jjjjjj,
-)
-
-x = "longer_than_90_charactersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss"
-"#;
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .arg("--config")
-        .arg(&ruff_toml)
-        .args(["--config", "line-length=90"])
-        .args(["--config", "lint.extend-select=['E501', 'F841']"])
-        .args(["--config", "lint.isort.combine-as-imports = false"])
-        .arg("-")
-        .pass_stdin(fixture), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    -:2:1: I001 [*] Import block is un-sorted or un-formatted
-    -:15:91: E501 Line too long (97 > 90)
-    Found 2 errors.
-    [*] 1 fixable with the `--fix` option.
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn valid_toml_but_nonexistent_option_provided_via_config_argument() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .args([".", "--config", "extend-select=['F481']"]),  // No such code as F481!
-        @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'extend-select=['F481']' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    Could not parse the supplied argument as a `ruff.toml` configuration option:
-
-    Unknown rule selector: `F481`
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn each_toml_option_requires_a_new_flag_1() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        // commas can't be used to delimit different config overrides;
-        // you need a new --config flag for each override
-        .args([".", "--config", "extend-select=['F841'], line-length=90"]),
-        @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'extend-select=['F841'], line-length=90' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    The supplied argument is not valid TOML:
-
-    TOML parse error at line 1, column 23
-      |
-    1 | extend-select=['F841'], line-length=90
-      |                       ^
-    expected newline, `#`
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn each_toml_option_requires_a_new_flag_2() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        // spaces *also* can't be used to delimit different config overrides;
-        // you need a new --config flag for each override
-        .args([".", "--config", "extend-select=['F841'] line-length=90"]),
-        @r###"
-    success: false
-    exit_code: 2
-    ----- stdout -----
-
-    ----- stderr -----
-    error: invalid value 'extend-select=['F841'] line-length=90' for '--config <CONFIG_OPTION>'
-
-      tip: A `--config` flag must either be a path to a `.toml` configuration file
-           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
-           option
-
-    The supplied argument is not valid TOML:
-
-    TOML parse error at line 1, column 24
-      |
-    1 | extend-select=['F841'] line-length=90
-      |                        ^
-    expected newline, `#`
-
-    For more information, try '--help'.
-    "###);
-}
-
-#[test]
-fn config_doubly_overridden_via_cli() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-line-length = 100
-
-[lint]
-select=["E501"]
-"#,
-    )?;
-    let fixture = "x = 'longer_than_90_charactersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss'";
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        // The --line-length flag takes priority over both the config file
-        // and the `--config="line-length=110"` flag,
-        // despite them both being specified after this flag on the command line:
-        .args(["--line-length", "90"])
-        .arg("--config")
-        .arg(&ruff_toml)
-        .args(["--config", "line-length=110"])
-        .arg("-")
-        .pass_stdin(fixture), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    -:1:91: E501 Line too long (97 > 90)
-    Found 1 error.
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn complex_config_setting_overridden_via_cli() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(&ruff_toml, "lint.select = ['N801']")?;
-    let fixture = "class violates_n801: pass";
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .arg("--config")
-        .arg(&ruff_toml)
-        .args(["--config", "lint.per-file-ignores = {'generated.py' = ['N801']}"])
-        .args(["--stdin-filename", "generated.py"])
-        .arg("-")
-        .pass_stdin(fixture), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn deprecated_config_option_overridden_via_cli() {
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .args(["--config", "select=['N801']", "-"])
-        .pass_stdin("class lowercase: ..."),
-        @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    -:1:7: N801 Class name `lowercase` should use CapWords convention 
-    Found 1 error.
-
-    ----- stderr -----
-    warning: The top-level linter settings are deprecated in favour of their counterparts in the `lint` section. Please update the following options in your `--config` CLI arguments:
-      - 'select' -> 'lint.select'
-    "###);
-}
-
 #[test]
 fn extension() -> Result<()> {
     let tempdir = TempDir::new()?;

crates/ruff/tests/show_settings.rs

@@ -4,29 +4,25 @@ use std::process::Command;
 
 const BIN_NAME: &str = "ruff";
 
+#[cfg(not(target_os = "windows"))]
+const TEST_FILTERS: &[(&str, &str)] = &[
+    ("\"[^\\*\"]*/pyproject.toml", "\"[BASEPATH]/pyproject.toml"),
+    ("\".*/crates", "\"[BASEPATH]/crates"),
+    ("\".*/\\.ruff_cache", "\"[BASEPATH]/.ruff_cache"),
+    ("\".*/ruff\"", "\"[BASEPATH]\""),
+];
+#[cfg(target_os = "windows")]
+const TEST_FILTERS: &[(&str, &str)] = &[
+    (r#""[^\*"]*\\pyproject.toml"#, "\"[BASEPATH]/pyproject.toml"),
+    (r#"".*\\crates"#, "\"[BASEPATH]/crates"),
+    (r#"".*\\\.ruff_cache"#, "\"[BASEPATH]/.ruff_cache"),
+    (r#"".*\\ruff""#, "\"[BASEPATH]\""),
+    (r#"\\+(\w\w|\s|")"#, "/$1"),
+];
+
 #[test]
 fn display_default_settings() {
-    // Navigate from the crate directory to the workspace root.
-    let base_path = Path::new(env!("CARGO_MANIFEST_DIR"))
-        .parent()
-        .unwrap()
-        .parent()
-        .unwrap();
-    let base_path = base_path.to_string_lossy();
-
-    // Escape the backslashes for the regex.
-    let base_path = regex::escape(&base_path);
-
-    #[cfg(not(target_os = "windows"))]
-    let test_filters = &[(base_path.as_ref(), "[BASEPATH]")];
-
-    #[cfg(target_os = "windows")]
-    let test_filters = &[
-        (base_path.as_ref(), "[BASEPATH]"),
-        (r#"\\+(\w\w|\s|\.|")"#, "/$1"),
-    ];
-
-    insta::with_settings!({ filters => test_filters.to_vec() }, {
+    insta::with_settings!({ filters => TEST_FILTERS.to_vec() }, {
         assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
             .args(["check", "--show-settings", "unformatted.py"]).current_dir(Path::new("./resources/test/fixtures")));
     });

crates/ruff/tests/snapshots/show_settings__display_default_settings.snap

@@ -205,9 +205,7 @@ linter.external = []
 linter.ignore_init_module_imports = false
 linter.logger_objects = []
 linter.namespace_packages = []
-linter.src = [
-	"[BASEPATH]",
-]
+linter.src = ["[BASEPATH]"]
 linter.tab_size = 4
 linter.line_length = 88
 linter.task_tags = [

crates/ruff_dev/src/format_dev.rs

@@ -27,7 +27,7 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::EnvFilter;
 
-use ruff::args::{ConfigArguments, FormatArguments, FormatCommand, LogLevelArgs};
+use ruff::args::{CliOverrides, FormatArguments, FormatCommand, LogLevelArgs};
 use ruff::resolve::resolve;
 use ruff_formatter::{FormatError, LineWidth, PrintError};
 use ruff_linter::logging::LogLevel;
@@ -38,23 +38,24 @@ use ruff_python_formatter::{
 use ruff_python_parser::ParseError;
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile, Resolver};
 
-fn parse_cli(dirs: &[PathBuf]) -> anyhow::Result<(FormatArguments, ConfigArguments)> {
+fn parse_cli(dirs: &[PathBuf]) -> anyhow::Result<(FormatArguments, CliOverrides)> {
     let args_matches = FormatCommand::command()
         .no_binary_name(true)
         .get_matches_from(dirs);
     let arguments: FormatCommand = FormatCommand::from_arg_matches(&args_matches)?;
-    let (cli, config_arguments) = arguments.partition()?;
-    Ok((cli, config_arguments))
+    let (cli, overrides) = arguments.partition();
+    Ok((cli, overrides))
 }
 
 /// Find the [`PyprojectConfig`] to use for formatting.
 fn find_pyproject_config(
     cli: &FormatArguments,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
 ) -> anyhow::Result<PyprojectConfig> {
     let mut pyproject_config = resolve(
         cli.isolated,
-        config_arguments,
+        cli.config.as_deref(),
+        overrides,
         cli.stdin_filename.as_deref(),
     )?;
     // We don't want to format pyproject.toml
@@ -71,9 +72,9 @@ fn find_pyproject_config(
 fn ruff_check_paths<'a>(
     pyproject_config: &'a PyprojectConfig,
     cli: &FormatArguments,
-    config_arguments: &ConfigArguments,
+    overrides: &CliOverrides,
 ) -> anyhow::Result<(Vec<Result<ResolvedFile, ignore::Error>>, Resolver<'a>)> {
-    let (paths, resolver) = python_files_in_path(&cli.files, pyproject_config, config_arguments)?;
+    let (paths, resolver) = python_files_in_path(&cli.files, pyproject_config, overrides)?;
     Ok((paths, resolver))
 }
 

crates/ruff_formatter/src/printer/line_suffixes.rs

@@ -21,7 +21,8 @@ impl<'a> LineSuffixes<'a> {
     /// Takes all the pending line suffixes.
     pub(super) fn take_pending<'l>(
         &'l mut self,
-    ) -> impl DoubleEndedIterator<Item = LineSuffixEntry<'a>> + 'l + ExactSizeIterator {
+    ) -> impl Iterator<Item = LineSuffixEntry<'a>> + DoubleEndedIterator + 'l + ExactSizeIterator
+    {
         self.suffixes.drain(..)
     }
 

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S308.py

@@ -1,22 +0,0 @@
-from django.utils.safestring import mark_safe
-
-
-def some_func():
-    return mark_safe('<script>alert("evil!")</script>')
-
-
-@mark_safe
-def some_func():
-    return '<script>alert("evil!")</script>'
-
-
-from django.utils.html import mark_safe
-
-
-def some_func():
-    return mark_safe('<script>alert("evil!")</script>')
-
-
-@mark_safe
-def some_func():
-    return '<script>alert("evil!")</script>'

crates/ruff_linter/resources/test/fixtures/flake8_trio/TRIO100.py

@@ -1,27 +1,18 @@
 import trio
 
 
-async def func():
+async def foo():
     with trio.fail_after():
         ...
 
-
-async def func():
+async def foo():
     with trio.fail_at():
         await ...
 
-
-async def func():
+async def foo():
     with trio.move_on_after():
         ...
 
-
-async def func():
+async def foo():
     with trio.move_at():
         await ...
-
-
-async def func():
-    with trio.move_at():
-        async with trio.open_nursery() as nursery:
-            ...

crates/ruff_linter/resources/test/fixtures/numpy/NPY002.py

@@ -19,11 +19,8 @@ numpy.random.seed()
 numpy.random.get_state()
 numpy.random.set_state()
 numpy.random.rand()
-numpy.random.ranf()
-numpy.random.sample()
 numpy.random.randn()
 numpy.random.randint()
-numpy.random.random()
 numpy.random.random_integers()
 numpy.random.random_sample()
 numpy.random.choice()
@@ -38,6 +35,7 @@ numpy.random.exponential()
 numpy.random.f()
 numpy.random.gamma()
 numpy.random.geometric()
+numpy.random.get_state()
 numpy.random.gumbel()
 numpy.random.hypergeometric()
 numpy.random.laplace()

crates/ruff_linter/resources/test/fixtures/pycodestyle/E30.py

@@ -1,848 +0,0 @@
-"""Fixtures for the errors E301, E302, E303, E304, E305 and E306.
-Since these errors are about new lines, each test starts with either "No error" or "# E30X".
-Each test's end is signaled by a "# end" line.
-There should be no E30X error outside of a test's bound.
-"""
-
-
-# No error
-class Class:
-    pass
-# end
-
-
-# No error
-class Class:
-    """Docstring"""
-    def __init__(self) -> None:
-        pass
-# end
-
-
-# No error
-def func():
-    pass
-# end
-
-
-# No error
-# comment
-class Class:
-    pass
-# end
-
-
-# No error
-# comment
-def func():
-    pass
-# end
-
-
-# no error
-def foo():
-    pass
-
-
-def bar():
-    pass
-
-
-class Foo(object):
-    pass
-
-
-class Bar(object):
-    pass
-# end
-
-
-# No error
-class Class(object):
-
-    def func1():
-        pass
-
-    def func2():
-        pass
-# end
-
-
-# No error
-class Class(object):
-
-    def func1():
-        pass
-
-# comment
-    def func2():
-        pass
-# end
-
-
-# No error
-class Class:
-
-    def func1():
-        pass
-
-    # comment
-    def func2():
-        pass
-
-    # This is a
-    # ... multi-line comment
-
-    def func3():
-        pass
-
-
-# This is a
-# ... multi-line comment
-
-@decorator
-class Class:
-
-    def func1():
-        pass
-
-    # comment
-
-    def func2():
-        pass
-
-    @property
-    def func3():
-        pass
-
-# end
-
-
-# No error
-try:
-    from nonexistent import Bar
-except ImportError:
-    class Bar(object):
-        """This is a Bar replacement"""
-# end
-
-
-# No error
-def with_feature(f):
-    """Some decorator"""
-    wrapper = f
-    if has_this_feature(f):
-        def wrapper(*args):
-            call_feature(args[0])
-            return f(*args)
-    return wrapper
-# end
-
-
-# No error
-try:
-    next
-except NameError:
-    def next(iterator, default):
-        for item in iterator:
-            return item
-        return default
-# end
-
-
-# No error
-def fn():
-    pass
-
-
-class Foo():
-    """Class Foo"""
-
-    def fn():
-
-        pass
-# end
-
-
-# No error
-# comment
-def c():
-    pass
-
-
-# comment
-
-
-def d():
-    pass
-
-# This is a
-# ... multi-line comment
-
-# And this one is
-# ... a second paragraph
-# ... which spans on 3 lines
-
-
-# Function `e` is below
-# NOTE: Hey this is a testcase
-
-def e():
-    pass
-
-
-def fn():
-    print()
-
-    # comment
-
-    print()
-
-    print()
-
-# Comment 1
-
-# Comment 2
-
-
-# Comment 3
-
-def fn2():
-
-    pass
-# end
-
-
-# no error
-if __name__ == '__main__':
-    foo()
-# end
-
-
-# no error
-defaults = {}
-defaults.update({})
-# end
-
-
-# no error
-def foo(x):
-    classification = x
-    definitely = not classification
-# end
-
-
-# no error
-def bar(): pass
-def baz(): pass
-# end
-
-
-# no error
-def foo():
-    def bar(): pass
-    def baz(): pass
-# end
-
-
-# no error
-from typing import overload
-from typing import Union
-# end
-
-
-# no error
-@overload
-def f(x: int) -> int: ...
-@overload
-def f(x: str) -> str: ...
-# end
-
-
-# no error
-def f(x: Union[int, str]) -> Union[int, str]:
-    return x
-# end
-
-
-# no error
-from typing import Protocol
-
-
-class C(Protocol):
-    @property
-    def f(self) -> int: ...
-    @property
-    def g(self) -> str: ...
-# end
-
-
-# no error
-def f(
-    a,
-):
-    pass
-# end
-
-
-# no error
-if True:
-    class Class:
-        """Docstring"""
-
-        def function(self):
-            ...
-# end
-
-
-# no error
-if True:
-    def function(self):
-        ...
-# end
-
-
-# no error
-@decorator
-# comment
-@decorator
-def function():
-    pass
-# end
-
-
-# no error
-class Class:
-    def method(self):
-        if True:
-            def function():
-                pass
-# end
-
-
-# no error
-@decorator
-async def function(data: None) -> None:
-    ...
-# end
-
-
-# no error
-class Class:
-    def method():
-        """docstring"""
-        # comment
-        def function():
-            pass
-# end
-
-
-# no error
-try:
-    if True:
-        # comment
-        class Class:
-            pass
-
-except:
-    pass
-# end
-
-
-# no error
-def f():
-    def f():
-        pass
-# end
-
-
-# no error
-class MyClass:
-    # comment
-    def method(self) -> None:
-        pass
-# end
-
-
-# no error
-def function1():
-    # Comment
-    def function2():
-        pass
-# end
-
-
-# no error
-async def function1():
-    await function2()
-    async with function3():
-        pass
-# end
-
-
-# no error
-if (
-    cond1
-
-
-
-
-    and cond2
-):
-    pass
-#end
-
-
-# no error
-async def function1():
-  await function2()
-  async with function3():
-    pass
-# end
-
-
-# no error
-async def function1():
-	await function2()
-	async with function3():
-		pass
-# end
-
-
-# no error
-async def function1():
-	await function2()
-    async with function3():
-    	pass
-# end
-
-
-# no error
-class Test:
-    async
-
-    def a(self): pass
-# end
-
-
-# no error
-class Test:
-    def a():
-        pass
-# wrongly indented comment
-
-    def b():
-        pass
-# end
-
-
-# no error
-def test():
-    pass
-  
-  # Wrongly indented comment
-    pass
-# end
-
-
-# E301
-class Class(object):
-
-    def func1():
-        pass
-    def func2():
-        pass
-# end
-
-
-# E301
-class Class:
-
-    def fn1():
-        pass
-    # comment
-    def fn2():
-        pass
-# end
-
-
-# E302
-"""Main module."""
-def fn():
-    pass
-# end
-
-
-# E302
-import sys
-def get_sys_path():
-    return sys.path
-# end
-
-
-# E302
-def a():
-    pass
-
-def b():
-    pass
-# end
-
-
-# E302
-def a():
-    pass
-
-# comment
-
-def b():
-    pass
-# end
-
-
-# E302
-def a():
-    pass
-
-async def b():
-    pass
-# end
-
-
-# E302
-async  def x():
-    pass
-
-async  def x(y: int = 1):
-    pass
-# end
-
-
-# E302
-def bar():
-    pass
-def baz(): pass
-# end
-
-
-# E302
-def bar(): pass
-def baz():
-    pass
-# end
-
-
-# E302
-def f():
-    pass
-
-# comment
-@decorator
-def g():
-    pass
-# end
-
-
-# E302
-class Test:
-	
-	pass
-	
-	def method1():
-		return 1
-		
-		
-	def method2():
-		return 22
-# end
-
-
-# E303
-def fn():
-    _ = None
-
-
-    # arbitrary comment
-
-    def inner():  # E306 not expected (pycodestyle detects E306)
-        pass
-# end
-
-
-# E303
-def fn():
-    _ = None
-
-
-    # arbitrary comment
-    def inner():  # E306 not expected (pycodestyle detects E306)
-        pass
-# end
-
-
-# E303
-print()
-
-
-
-print()
-# end
-
-
-# E303:5:1
-print()
-
-
-
-# comment
-
-print()
-# end
-
-
-# E303:5:5 E303:8:5
-def a():
-    print()
-
-
-    # comment
-
-
-    # another comment
-
-    print()
-# end
-
-
-# E303
-#!python
-
-
-
-"""This class docstring comes on line 5.
-It gives error E303: too many blank lines (3)
-"""
-# end
-
-
-# E303
-class Class:
-    def a(self):
-        pass
-
-
-    def b(self):
-        pass
-# end
-
-
-# E303
-if True:
-    a = 1
-
-
-    a = 2
-# end
-
-
-# E303
-class Test:
-
-
-    # comment
-
-
-    # another comment
-
-    def test(self): pass
-# end
-
-
-# E303
-class Test:
-    def a(self):
-        pass
-
-# wrongly indented comment
-
-
-    def b(self):
-        pass
-# end
-
-
-# E303
-def fn():
-    pass
-
- 
-    pass
-# end
-
-
-# E304
-@decorator
-
-def function():
-    pass
-# end
-
-
-# E304
-@decorator
-
-# comment    E304 not expected
-def function():
-    pass
-# end
-
-
-# E304
-@decorator
-
-# comment  E304 not expected
-
-
-# second comment  E304 not expected
-def function():
-    pass
-# end
-
-
-# E305:7:1
-def fn():
-    print()
-
-    # comment
-
-    # another comment
-fn()
-# end
-
-
-# E305
-class Class():
-    pass
-
-    # comment
-
-    # another comment
-a = 1
-# end
-
-
-# E305:8:1
-def fn():
-    print()
-
-    # comment
-
-    # another comment
-
-try:
-    fn()
-except Exception:
-    pass
-# end
-
-
-# E305:5:1
-def a():
-    print()
-
-# Two spaces before comments, too.
-if a():
-    a()
-# end
-
-
-#: E305:8:1
-# Example from https://github.com/PyCQA/pycodestyle/issues/400
-import stuff
-
-
-def main():
-    blah, blah
-
-if __name__ == '__main__':
-    main()
-# end
-
-
-# E306:3:5
-def a():
-    x = 1
-    def b():
-        pass
-# end
-
-
-#: E306:3:5
-async def a():
-    x = 1
-    def b():
-        pass
-# end
-
-
-#: E306:3:5 E306:5:9
-def a():
-    x = 2
-    def b():
-        x = 1
-        def c():
-            pass
-# end
-
-
-# E306:3:5 E306:6:5
-def a():
-    x = 1
-    class C:
-        pass
-    x = 2
-    def b():
-        pass
-# end
-
-
-# E306
-def foo():
-    def bar():
-        pass
-    def baz(): pass
-# end
-
-
-# E306:3:5
-def foo():
-    def bar(): pass
-    def baz():
-        pass
-# end
-
-
-# E306
-def a():
-    x = 2
-    @decorator
-    def b():
-        pass
-# end
-
-
-# E306
-def a():
-    x = 2
-    @decorator
-    async def b():
-        pass
-# end
-
-
-# E306
-def a():
-    x = 2
-    async def b():
-        pass
-# end

crates/ruff_linter/resources/test/fixtures/pydocstyle/sections.py

@@ -562,46 +562,3 @@ def titlecase_sub_section_header():
 
         Returns:
     """
-
-
-def test_method_should_be_correctly_capitalized(parameters: list[str], other_parameters: dict[str, str]): # noqa: D213
-    """Test parameters and attributes sections are capitalized correctly.
-
-    Parameters
-    ----------
-    parameters:
-        A list of string parameters
-    other_parameters:
-        A dictionary of string attributes
-
-    Other Parameters
-    ----------
-    other_parameters:
-        A dictionary of string attributes
-    parameters:
-        A list of string parameters
-
-    """
-
-
-def test_lowercase_sub_section_header_should_be_valid(parameters: list[str], value: int):  # noqa: D213
-    """Test that lower case subsection header is valid even if it has the same name as section kind.
-
-    Parameters:
-    ----------
-    parameters:
-        A list of string parameters
-    value:
-        Some value
-    """
-
-
-def test_lowercase_sub_section_header_different_kind(returns: int):
-   """Test that lower case subsection header is valid even if it is of a different kind.
-
-   Parameters
-   -‐-----------------
-   returns:
-       some value
-
-   """

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.py

@@ -46,8 +46,3 @@ x: typing.TypeAlias = list[T]
 # OK
 x: TypeAlias
 x: int = 1
-
-# Ensure that "T" appears only once  in the type parameters for the modernized
-# type alias.
-T = typing.TypeVar["T"]
-Decorator: TypeAlias = typing.Callable[[T], T]

crates/ruff_linter/resources/test/fixtures/ruff/RUF022.py

@@ -250,23 +250,6 @@ __all__ = (
     ,
 )
 
-__all__ = (  # comment about the opening paren
-    # multiline strange comment 0a
-    # multiline strange comment 0b
-    "foo"  # inline comment about foo
-    # multiline strange comment 1a
-    # multiline strange comment 1b
-    ,  # comment about the comma??
-    # comment about bar part a
-    # comment about bar part b
-    "bar"  # inline comment about bar
-    # strange multiline comment comment 2a
-    # strange multiline comment 2b
-    ,
-    # strange multiline comment 3a
-    # strange multiline comment 3b
-)  # comment about the closing paren
-
 ###################################
 # These should all not get flagged:
 ###################################

crates/ruff_linter/resources/test/fixtures/ruff/RUF023.py

@@ -188,10 +188,6 @@ class BezierBuilder4:
         ,
     )
 
-    __slots__ = {"foo", "bar",
-                 "baz", "bingo"
-                 }
-
 ###################################
 # These should all not get flagged:
 ###################################

crates/ruff_linter/resources/test/fixtures/ruff/RUF027.py

@@ -0,0 +1,85 @@
+val = 2
+
+def simple_cases():
+    a = 4
+    b = "{a}" # RUF027
+    c = "{a} {b} f'{val}' " # RUF027
+
+def escaped_string():
+    a = 4
+    b = "escaped string: {{ brackets surround me }}" # RUF027
+
+def raw_string():
+    a = 4
+    b = r"raw string with formatting: {a}" # RUF027
+    c = r"raw string with \backslashes\ and \"escaped quotes\": {a}" # RUF027
+
+def print_name(name: str):
+    a = 4
+    print("Hello, {name}!") # RUF027
+    print("The test value we're using today is {a}") # RUF027
+
+def do_nothing(a):
+    return a
+
+def nested_funcs():
+    a = 4
+    print(do_nothing(do_nothing("{a}"))) # RUF027
+
+def tripled_quoted():
+    a = 4
+    c = a
+    single_line = """ {a} """ # RUF027
+    # RUF027
+    multi_line = a = """b { # comment
+    c}  d
+    """
+    
+def single_quoted_multi_line():
+    a = 4
+    # RUF027
+    b = " {\
+    a} \
+    "
+
+def implicit_concat():
+    a = 4
+    b = "{a}" "+" "{b}" r" \\ " # RUF027 for the first part only
+    print(f"{a}" "{a}" f"{b}") # RUF027
+
+def escaped_chars():
+    a = 4
+    b = "\"not escaped:\" \'{a}\' \"escaped:\": \'{{c}}\'" # RUF027
+
+def alternative_formatter(src, **kwargs):
+    src.format(**kwargs)
+
+def format2(src, *args):
+    pass
+
+# These should not cause an RUF027 message
+def negative_cases():
+    a = 4
+    positive = False
+    """{a}"""
+    "don't format: {a}"
+    c = """  {b} """
+    d = "bad variable: {invalid}"
+    e = "incorrect syntax: {}"
+    json = "{ positive: false }"
+    json2 = "{ 'positive': false }"
+    json3 = "{ 'positive': 'false' }"
+    alternative_formatter("{a}", a = 5)
+    formatted = "{a}".fmt(a = 7)
+    print(do_nothing("{a}".format(a=3)))
+    print(do_nothing(alternative_formatter("{a}", a = 5)))
+    print(format(do_nothing("{a}"), a = 5))
+    print("{a}".to_upper())
+    print(do_nothing("{a}").format(a = "Test"))
+    print(do_nothing("{a}").format2(a))
+
+a = 4
+
+"always ignore this: {a}"
+
+print("but don't ignore this: {val}") # RUF027

crates/ruff_linter/resources/test/fixtures/ruff/RUF027_0.py

@@ -1,70 +0,0 @@
-val = 2
-
-"always ignore this: {val}"
-
-print("but don't ignore this: {val}")  # RUF027
-
-
-def simple_cases():
-    a = 4
-    b = "{a}"  # RUF027
-    c = "{a} {b} f'{val}' "  # RUF027
-
-
-def escaped_string():
-    a = 4
-    b = "escaped string: {{ brackets surround me }}"  # RUF027
-
-
-def raw_string():
-    a = 4
-    b = r"raw string with formatting: {a}"  # RUF027
-    c = r"raw string with \backslashes\ and \"escaped quotes\": {a}"  # RUF027
-
-
-def print_name(name: str):
-    a = 4
-    print("Hello, {name}!")  # RUF027
-    print("The test value we're using today is {a}")  # RUF027
-
-
-def nested_funcs():
-    a = 4
-    print(do_nothing(do_nothing("{a}")))  # RUF027
-
-
-def tripled_quoted():
-    a = 4
-    c = a
-    single_line = """ {a} """  # RUF027
-    # RUF027
-    multi_line = a = """b { # comment
-    c}  d
-    """
-
-
-def single_quoted_multi_line():
-    a = 4
-    # RUF027
-    b = " {\
-    a} \
-    "
-
-
-def implicit_concat():
-    a = 4
-    b = "{a}" "+" "{b}" r" \\ "  # RUF027 for the first part only
-    print(f"{a}" "{a}" f"{b}")  # RUF027
-
-
-def escaped_chars():
-    a = 4
-    b = "\"not escaped:\" '{a}' \"escaped:\": '{{c}}'"  # RUF027
-
-
-def method_calls():
-    value = {}
-    value.method = print_name
-    first = "Wendy"
-    last = "Appleseed"
-    value.method("{first} {last}")  # RUF027

crates/ruff_linter/resources/test/fixtures/ruff/RUF027_1.py

@@ -1,36 +0,0 @@
-def do_nothing(a):
-    return a
-
-
-def alternative_formatter(src, **kwargs):
-    src.format(**kwargs)
-
-
-def format2(src, *args):
-    pass
-
-
-# These should not cause an RUF027 message
-def negative_cases():
-    a = 4
-    positive = False
-    """{a}"""
-    "don't format: {a}"
-    c = """  {b} """
-    d = "bad variable: {invalid}"
-    e = "incorrect syntax: {}"
-    f = "uses a builtin: {max}"
-    json = "{ positive: false }"
-    json2 = "{ 'positive': false }"
-    json3 = "{ 'positive': 'false' }"
-    alternative_formatter("{a}", a=5)
-    formatted = "{a}".fmt(a=7)
-    print(do_nothing("{a}".format(a=3)))
-    print(do_nothing(alternative_formatter("{a}", a=5)))
-    print(format(do_nothing("{a}"), a=5))
-    print("{a}".to_upper())
-    print(do_nothing("{a}").format(a="Test"))
-    print(do_nothing("{a}").format2(a))
-    print(("{a}" "{c}").format(a=1, c=2))
-    print("{a}".attribute.chaining.call(a=2))
-    print("{a} {c}".format(a))

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -343,16 +343,15 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
         Expr::Call(
             call @ ast::ExprCall {
                 func,
-                arguments,
+                arguments:
+                    Arguments {
+                        args,
+                        keywords,
+                        range: _,
+                    },
                 range: _,
             },
         ) => {
-            let Arguments {
-                args,
-                keywords,
-                range: _,
-            } = &**arguments;
-
             if checker.any_enabled(&[
                 // pylint
                 Rule::BadStringFormatCharacter,

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -247,11 +247,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::HardcodedPasswordDefault) {
                 flake8_bandit::rules::hardcoded_password_default(checker, parameters);
             }
-            if checker.enabled(Rule::SuspiciousMarkSafeUsage) {
-                for decorator in decorator_list {
-                    flake8_bandit::rules::suspicious_function_decorator(checker, decorator);
-                }
-            }
             if checker.enabled(Rule::PropertyWithParameters) {
                 pylint::rules::property_with_parameters(checker, stmt, decorator_list, parameters);
             }

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -31,8 +31,8 @@ use std::path::Path;
 use itertools::Itertools;
 use log::debug;
 use ruff_python_ast::{
-    self as ast, Comprehension, ElifElseClause, ExceptHandler, Expr, ExprContext, Keyword,
-    MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt, Suite, UnaryOp,
+    self as ast, Arguments, Comprehension, ElifElseClause, ExceptHandler, Expr, ExprContext,
+    Keyword, MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt, Suite, UnaryOp,
 };
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
@@ -904,7 +904,7 @@ where
                 range: _,
             }) => {
                 if let Expr::Name(ast::ExprName { id, ctx, range: _ }) = func.as_ref() {
-                    if &**id == "locals" && ctx.is_load() {
+                    if id == "locals" && ctx.is_load() {
                         let scope = self.semantic.current_scope_mut();
                         scope.set_uses_locals();
                     }
@@ -989,7 +989,12 @@ where
             }
             Expr::Call(ast::ExprCall {
                 func,
-                arguments,
+                arguments:
+                    Arguments {
+                        args,
+                        keywords,
+                        range: _,
+                    },
                 range: _,
             }) => {
                 self.visit_expr(func);
@@ -1032,7 +1037,7 @@ where
                 });
                 match callable {
                     Some(typing::Callable::Bool) => {
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_boolean_test(arg);
                         }
@@ -1041,7 +1046,7 @@ where
                         }
                     }
                     Some(typing::Callable::Cast) => {
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_type_definition(arg);
                         }
@@ -1050,7 +1055,7 @@ where
                         }
                     }
                     Some(typing::Callable::NewType) => {
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_non_type_definition(arg);
                         }
@@ -1059,21 +1064,21 @@ where
                         }
                     }
                     Some(typing::Callable::TypeVar) => {
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_non_type_definition(arg);
                         }
                         for arg in args {
                             self.visit_type_definition(arg);
                         }
-                        for keyword in arguments.keywords.iter() {
+                        for keyword in keywords {
                             let Keyword {
                                 arg,
                                 value,
                                 range: _,
                             } = keyword;
                             if let Some(id) = arg {
-                                if &**id == "bound" {
+                                if id == "bound" {
                                     self.visit_type_definition(value);
                                 } else {
                                     self.visit_non_type_definition(value);
@@ -1083,7 +1088,7 @@ where
                     }
                     Some(typing::Callable::NamedTuple) => {
                         // Ex) NamedTuple("a", [("a", int)])
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_non_type_definition(arg);
                         }
@@ -1112,12 +1117,12 @@ where
                             }
                         }
 
-                        for keyword in arguments.keywords.iter() {
+                        for keyword in keywords {
                             let Keyword { arg, value, .. } = keyword;
                             match (arg.as_ref(), value) {
                                 // Ex) NamedTuple("a", **{"a": int})
                                 (None, Expr::Dict(ast::ExprDict { keys, values, .. })) => {
-                                    for (key, value) in keys.iter().zip(values.iter()) {
+                                    for (key, value) in keys.iter().zip(values) {
                                         if let Some(key) = key.as_ref() {
                                             self.visit_non_type_definition(key);
                                             self.visit_type_definition(value);
@@ -1139,7 +1144,7 @@ where
                     }
                     Some(typing::Callable::TypedDict) => {
                         // Ex) TypedDict("a", {"a": int})
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             self.visit_non_type_definition(arg);
                         }
@@ -1153,7 +1158,7 @@ where
                                 for key in keys.iter().flatten() {
                                     self.visit_non_type_definition(key);
                                 }
-                                for value in values.iter() {
+                                for value in values {
                                     self.visit_type_definition(value);
                                 }
                             } else {
@@ -1162,13 +1167,13 @@ where
                         }
 
                         // Ex) TypedDict("a", a=int)
-                        for keyword in arguments.keywords.iter() {
+                        for keyword in keywords {
                             let Keyword { value, .. } = keyword;
                             self.visit_type_definition(value);
                         }
                     }
                     Some(typing::Callable::MypyExtension) => {
-                        let mut args = arguments.args.iter();
+                        let mut args = args.iter();
                         if let Some(arg) = args.next() {
                             // Ex) DefaultNamedArg(bool | None, name="some_prop_name")
                             self.visit_type_definition(arg);
@@ -1176,13 +1181,13 @@ where
                             for arg in args {
                                 self.visit_non_type_definition(arg);
                             }
-                            for keyword in arguments.keywords.iter() {
+                            for keyword in keywords {
                                 let Keyword { value, .. } = keyword;
                                 self.visit_non_type_definition(value);
                             }
                         } else {
                             // Ex) DefaultNamedArg(type="bool", name="some_prop_name")
-                            for keyword in arguments.keywords.iter() {
+                            for keyword in keywords {
                                 let Keyword {
                                     value,
                                     arg,
@@ -1200,10 +1205,10 @@ where
                         // If we're in a type definition, we need to treat the arguments to any
                         // other callables as non-type definitions (i.e., we don't want to treat
                         // any strings as deferred type definitions).
-                        for arg in arguments.args.iter() {
+                        for arg in args {
                             self.visit_non_type_definition(arg);
                         }
-                        for keyword in arguments.keywords.iter() {
+                        for keyword in keywords {
                             let Keyword { value, .. } = keyword;
                             self.visit_non_type_definition(value);
                         }
@@ -1755,21 +1760,21 @@ impl<'a> Checker<'a> {
             && match parent {
                 Stmt::Assign(ast::StmtAssign { targets, .. }) => {
                     if let Some(Expr::Name(ast::ExprName { id, .. })) = targets.first() {
-                        &**id == "__all__"
+                        id == "__all__"
                     } else {
                         false
                     }
                 }
                 Stmt::AugAssign(ast::StmtAugAssign { target, .. }) => {
                     if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
-                        &**id == "__all__"
+                        id == "__all__"
                     } else {
                         false
                     }
                 }
                 Stmt::AnnAssign(ast::StmtAnnAssign { target, .. }) => {
                     if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
-                        &**id == "__all__"
+                        id == "__all__"
                     } else {
                         false
                     }

crates/ruff_linter/src/checkers/imports.rs

@@ -46,7 +46,7 @@ fn extract_import_map(path: &Path, package: Option<&Path>, blocks: &[&Block]) ->
             }) => {
                 let level = level.unwrap_or_default() as usize;
                 let module = if let Some(module) = module {
-                    let module: &str = module.as_str();
+                    let module: &String = module.as_ref();
                     if level == 0 {
                         Cow::Borrowed(module)
                     } else {

crates/ruff_linter/src/checkers/logical_lines.rs

@@ -1,4 +1,3 @@
-use crate::line_width::IndentWidth;
 use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_parser::lexer::LexResult;
@@ -16,11 +15,11 @@ use crate::rules::pycodestyle::rules::logical_lines::{
 use crate::settings::LinterSettings;
 
 /// Return the amount of indentation, expanding tabs to the next multiple of the settings' tab size.
-pub(crate) fn expand_indent(line: &str, indent_width: IndentWidth) -> usize {
+fn expand_indent(line: &str, settings: &LinterSettings) -> usize {
     let line = line.trim_end_matches(['\n', '\r']);
 
     let mut indent = 0;
-    let tab_size = indent_width.as_usize();
+    let tab_size = settings.tab_size.as_usize();
     for c in line.bytes() {
         match c {
             b'\t' => indent = (indent / tab_size) * tab_size + tab_size,
@@ -86,7 +85,7 @@ pub(crate) fn check_logical_lines(
             TextRange::new(locator.line_start(first_token.start()), first_token.start())
         };
 
-        let indent_level = expand_indent(locator.slice(range), settings.tab_size);
+        let indent_level = expand_indent(locator.slice(range), settings);
 
         let indent_size = 4;
 

crates/ruff_linter/src/checkers/tokens.rs

@@ -4,7 +4,6 @@ use std::path::Path;
 
 use ruff_notebook::CellOffsets;
 use ruff_python_ast::PySourceType;
-use ruff_python_codegen::Stylist;
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
 
@@ -15,7 +14,6 @@ use ruff_source_file::Locator;
 use crate::directives::TodoComment;
 use crate::lex::docstring_detection::StateMachine;
 use crate::registry::{AsRule, Rule};
-use crate::rules::pycodestyle::rules::BlankLinesChecker;
 use crate::rules::ruff::rules::Context;
 use crate::rules::{
     eradicate, flake8_commas, flake8_executable, flake8_fixme, flake8_implicit_str_concat,
@@ -23,37 +21,17 @@ use crate::rules::{
 };
 use crate::settings::LinterSettings;
 
-#[allow(clippy::too_many_arguments)]
 pub(crate) fn check_tokens(
     tokens: &[LexResult],
     path: &Path,
     locator: &Locator,
     indexer: &Indexer,
-    stylist: &Stylist,
     settings: &LinterSettings,
     source_type: PySourceType,
     cell_offsets: Option<&CellOffsets>,
 ) -> Vec<Diagnostic> {
     let mut diagnostics: Vec<Diagnostic> = vec![];
 
-    if settings.rules.any_enabled(&[
-        Rule::BlankLineBetweenMethods,
-        Rule::BlankLinesTopLevel,
-        Rule::TooManyBlankLines,
-        Rule::BlankLineAfterDecorator,
-        Rule::BlankLinesAfterFunctionOrClass,
-        Rule::BlankLinesBeforeNestedDefinition,
-    ]) {
-        let mut blank_lines_checker = BlankLinesChecker::default();
-        blank_lines_checker.check_lines(
-            tokens,
-            locator,
-            stylist,
-            settings.tab_size,
-            &mut diagnostics,
-        );
-    }
-
     if settings.rules.enabled(Rule::BlanketNOQA) {
         pygrep_hooks::rules::blanket_noqa(&mut diagnostics, indexer, locator);
     }
@@ -117,7 +95,7 @@ pub(crate) fn check_tokens(
     }
 
     if settings.rules.enabled(Rule::TabIndentation) {
-        pycodestyle::rules::tab_indentation(&mut diagnostics, locator, indexer);
+        pycodestyle::rules::tab_indentation(&mut diagnostics, tokens, locator, indexer);
     }
 
     if settings.rules.any_enabled(&[

crates/ruff_linter/src/codes.rs

@@ -137,12 +137,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pycodestyle, "E274") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::TabBeforeKeyword),
         #[allow(deprecated)]
         (Pycodestyle, "E275") => (RuleGroup::Nursery, rules::pycodestyle::rules::logical_lines::MissingWhitespaceAfterKeyword),
-        (Pycodestyle, "E301") => (RuleGroup::Preview, rules::pycodestyle::rules::BlankLineBetweenMethods),
-        (Pycodestyle, "E302") => (RuleGroup::Preview, rules::pycodestyle::rules::BlankLinesTopLevel),
-        (Pycodestyle, "E303") => (RuleGroup::Preview, rules::pycodestyle::rules::TooManyBlankLines),
-        (Pycodestyle, "E304") => (RuleGroup::Preview, rules::pycodestyle::rules::BlankLineAfterDecorator),
-        (Pycodestyle, "E305") => (RuleGroup::Preview, rules::pycodestyle::rules::BlankLinesAfterFunctionOrClass),
-        (Pycodestyle, "E306") => (RuleGroup::Preview, rules::pycodestyle::rules::BlankLinesBeforeNestedDefinition),
         (Pycodestyle, "E401") => (RuleGroup::Stable, rules::pycodestyle::rules::MultipleImportsOnOneLine),
         (Pycodestyle, "E402") => (RuleGroup::Stable, rules::pycodestyle::rules::ModuleImportNotAtTopOfFile),
         (Pycodestyle, "E501") => (RuleGroup::Stable, rules::pycodestyle::rules::LineTooLong),

crates/ruff_linter/src/docstrings/sections.rs

@@ -5,7 +5,7 @@ use ruff_python_ast::docstrings::{leading_space, leading_words};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 use strum_macros::EnumIter;
 
-use ruff_source_file::{Line, NewlineWithTrailingNewline, UniversalNewlines};
+use ruff_source_file::{Line, UniversalNewlineIterator, UniversalNewlines};
 
 use crate::docstrings::styles::SectionStyle;
 use crate::docstrings::{Docstring, DocstringBody};
@@ -130,34 +130,6 @@ impl SectionKind {
             Self::Yields => "Yields",
         }
     }
-
-    /// Returns `true` if a section can contain subsections, as in:
-    /// ```python
-    /// Yields
-    /// ------
-    /// int
-    ///     Description of the anonymous integer return value.
-    /// ```
-    ///
-    /// For NumPy, see: <https://numpydoc.readthedocs.io/en/latest/format.html>
-    ///
-    /// For Google, see: <https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings>
-    pub(crate) fn has_subsections(self) -> bool {
-        matches!(
-            self,
-            Self::Args
-                | Self::Arguments
-                | Self::OtherArgs
-                | Self::OtherParameters
-                | Self::OtherParams
-                | Self::Parameters
-                | Self::Raises
-                | Self::Returns
-                | Self::SeeAlso
-                | Self::Warns
-                | Self::Yields
-        )
-    }
 }
 
 pub(crate) struct SectionContexts<'a> {
@@ -384,16 +356,13 @@ impl<'a> SectionContext<'a> {
     pub(crate) fn previous_line(&self) -> Option<&'a str> {
         let previous =
             &self.docstring_body.as_str()[TextRange::up_to(self.range_relative().start())];
-        previous
-            .universal_newlines()
-            .last()
-            .map(|line| line.as_str())
+        previous.universal_newlines().last().map(|l| l.as_str())
     }
 
     /// Returns the lines belonging to this section after the summary line.
-    pub(crate) fn following_lines(&self) -> NewlineWithTrailingNewline<'a> {
+    pub(crate) fn following_lines(&self) -> UniversalNewlineIterator<'a> {
         let lines = self.following_lines_str();
-        NewlineWithTrailingNewline::with_offset(lines, self.offset() + self.data.summary_full_end)
+        UniversalNewlineIterator::with_offset(lines, self.offset() + self.data.summary_full_end)
     }
 
     fn following_lines_str(&self) -> &'a str {
@@ -490,54 +459,13 @@ fn is_docstring_section(
     //         args: The arguments to the function.
     //     """
     // ```
-    // Or `parameters` in:
-    // ```python
-    // def func(parameters: tuple[int]):
-    //     """Toggle the gizmo.
-    //
-    //     Parameters:
-    //     -----
-    //     parameters:
-    //         The arguments to the function.
-    //     """
-    // ```
     // However, if the header is an _exact_ match (like `Returns:`, as opposed to `returns:`), then
     // continue to treat it as a section header.
-    if section_kind.has_subsections() {
-        if let Some(previous_section) = previous_section {
+    if let Some(previous_section) = previous_section {
+        if previous_section.indent_size < indent_size {
             let verbatim = &line[TextRange::at(indent_size, section_name_size)];
-
-            // If the section is more deeply indented, assume it's a subsection, as in:
-            // ```python
-            // def func(args: tuple[int]):
-            //     """Toggle the gizmo.
-            //
-            //     Args:
-            //         args: The arguments to the function.
-            //     """
-            // ```
-            if previous_section.indent_size < indent_size {
-                if section_kind.as_str() != verbatim {
-                    return false;
-                }
-            }
-
-            // If the section isn't underlined, and isn't title-cased, assume it's a subsection,
-            // as in:
-            // ```python
-            // def func(parameters: tuple[int]):
-            //     """Toggle the gizmo.
-            //
-            //     Parameters:
-            //     -----
-            //     parameters:
-            //         The arguments to the function.
-            //     """
-            // ```
-            if !next_line_is_underline && verbatim.chars().next().is_some_and(char::is_lowercase) {
-                if section_kind.as_str() != verbatim {
-                    return false;
-                }
+            if section_kind.as_str() != verbatim {
+                return false;
             }
         }
     }

crates/ruff_linter/src/linter.rs

@@ -109,7 +109,6 @@ pub fn check_path(
             path,
             locator,
             indexer,
-            stylist,
             settings,
             source_type,
             source_kind.as_ipy_notebook().map(Notebook::cell_offsets),

crates/ruff_linter/src/registry.rs

@@ -264,11 +264,6 @@ impl Rule {
             | Rule::BadQuotesMultilineString
             | Rule::BlanketNOQA
             | Rule::BlanketTypeIgnore
-            | Rule::BlankLineAfterDecorator
-            | Rule::BlankLineBetweenMethods
-            | Rule::BlankLinesAfterFunctionOrClass
-            | Rule::BlankLinesBeforeNestedDefinition
-            | Rule::BlankLinesTopLevel
             | Rule::CommentedOutCode
             | Rule::EmptyComment
             | Rule::ExtraneousParentheses
@@ -301,7 +296,6 @@ impl Rule {
             | Rule::ShebangNotFirstLine
             | Rule::SingleLineImplicitStringConcatenation
             | Rule::TabIndentation
-            | Rule::TooManyBlankLines
             | Rule::TrailingCommaOnBareTuple
             | Rule::TypeCommentInStub
             | Rule::UselessSemicolon

crates/ruff_linter/src/rule_selector.rs

@@ -321,16 +321,6 @@ mod schema {
                             true
                         }
                     })
-                    .filter(|_rule| {
-                        // Filter out all test-only rules
-                        #[cfg(feature = "test-rules")]
-                        #[allow(clippy::used_underscore_binding)]
-                        if _rule.starts_with("RUF9") {
-                            return false;
-                        }
-
-                        true
-                    })
                     .sorted()
                     .map(Value::String)
                     .collect(),

crates/ruff_linter/src/rules/airflow/rules/task_variable_name.rs

@@ -81,7 +81,7 @@ pub(crate) fn variable_name_task_id(
     let ast::ExprStringLiteral { value: task_id, .. } = keyword.value.as_string_literal_expr()?;
 
     // If the target name is the same as the task_id, no violation.
-    if task_id == &**id {
+    if task_id == id {
         return None;
     }
 

crates/ruff_linter/src/rules/flake8_annotations/helpers.rs

@@ -137,7 +137,7 @@ impl AutoPythonType {
                     )
                     .ok()?;
                 let expr = Expr::Name(ast::ExprName {
-                    id: binding.into_boxed_str(),
+                    id: binding,
                     range: TextRange::default(),
                     ctx: ExprContext::Load,
                 });

crates/ruff_linter/src/rules/flake8_bandit/mod.rs

@@ -46,7 +46,6 @@ mod tests {
     #[test_case(Rule::SubprocessWithoutShellEqualsTrue, Path::new("S603.py"))]
     #[test_case(Rule::SuspiciousPickleUsage, Path::new("S301.py"))]
     #[test_case(Rule::SuspiciousEvalUsage, Path::new("S307.py"))]
-    #[test_case(Rule::SuspiciousMarkSafeUsage, Path::new("S308.py"))]
     #[test_case(Rule::SuspiciousURLOpenUsage, Path::new("S310.py"))]
     #[test_case(Rule::SuspiciousTelnetUsage, Path::new("S312.py"))]
     #[test_case(Rule::SuspiciousTelnetlibImport, Path::new("S401.py"))]

crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_bind_all_interfaces.rs

@@ -40,9 +40,7 @@ impl Violation for HardcodedBindAllInterfaces {
 pub(crate) fn hardcoded_bind_all_interfaces(checker: &mut Checker, string: StringLike) {
     let is_bind_all_interface = match string {
         StringLike::StringLiteral(ast::ExprStringLiteral { value, .. }) => value == "0.0.0.0",
-        StringLike::FStringLiteral(ast::FStringLiteralElement { value, .. }) => {
-            &**value == "0.0.0.0"
-        }
+        StringLike::FStringLiteral(ast::FStringLiteralElement { value, .. }) => value == "0.0.0.0",
         StringLike::BytesLiteral(_) => return,
     };
 

crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_password_string.rs

@@ -52,7 +52,7 @@ impl Violation for HardcodedPasswordString {
 fn password_target(target: &Expr) -> Option<&str> {
     let target_name = match target {
         // variable = "s3cr3t"
-        Expr::Name(ast::ExprName { id, .. }) => &**id,
+        Expr::Name(ast::ExprName { id, .. }) => id.as_str(),
         // d["password"] = "s3cr3t"
         Expr::Subscript(ast::ExprSubscript { slice, .. }) => match slice.as_ref() {
             Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value.to_str(),

crates/ruff_linter/src/rules/flake8_bandit/rules/jinja2_autoescape_false.rs

@@ -69,7 +69,7 @@ pub(crate) fn jinja2_autoescape_false(checker: &mut Checker, call: &ast::ExprCal
                 Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: true, .. }) => (),
                 Expr::Call(ast::ExprCall { func, .. }) => {
                     if let Expr::Name(ast::ExprName { id, .. }) = func.as_ref() {
-                        if &**id != "select_autoescape" {
+                        if id != "select_autoescape" {
                             checker.diagnostics.push(Diagnostic::new(
                                 Jinja2AutoescapeFalse { value: true },
                                 keyword.range(),

crates/ruff_linter/src/rules/flake8_bandit/rules/ssl_with_bad_defaults.rs

@@ -64,7 +64,7 @@ pub(crate) fn ssl_with_bad_defaults(checker: &mut Checker, function_def: &StmtFu
             if let Some(default) = &param.default {
                 match default.as_ref() {
                     Expr::Name(ast::ExprName { id, range, .. }) => {
-                        if is_insecure_protocol(id) {
+                        if is_insecure_protocol(id.as_str()) {
                             checker.diagnostics.push(Diagnostic::new(
                                 SslWithBadDefaults {
                                     protocol: id.to_string(),

crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_function_call.rs

@@ -3,7 +3,7 @@
 //! See: <https://bandit.readthedocs.io/en/latest/blacklists/blacklist_calls.html>
 use ruff_diagnostics::{Diagnostic, DiagnosticKind, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Decorator, Expr, ExprCall};
+use ruff_python_ast::{self as ast, Expr, ExprCall};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -848,7 +848,7 @@ pub(crate) fn suspicious_function_call(checker: &mut Checker, call: &ExprCall) {
             // Eval
             ["" | "builtins", "eval"] => Some(SuspiciousEvalUsage.into()),
             // MarkSafe
-            ["django", "utils", "safestring" | "html", "mark_safe"] => Some(SuspiciousMarkSafeUsage.into()),
+            ["django", "utils", "safestring", "mark_safe"] => Some(SuspiciousMarkSafeUsage.into()),
             // URLOpen (`urlopen`, `urlretrieve`, `Request`)
             ["urllib", "request", "urlopen" | "urlretrieve" | "Request"] |
             ["six", "moves", "urllib", "request", "urlopen" | "urlretrieve" | "Request"] => {
@@ -901,27 +901,3 @@ pub(crate) fn suspicious_function_call(checker: &mut Checker, call: &ExprCall) {
         checker.diagnostics.push(diagnostic);
     }
 }
-
-/// S308
-pub(crate) fn suspicious_function_decorator(checker: &mut Checker, decorator: &Decorator) {
-    let Some(diagnostic_kind) = checker
-        .semantic()
-        .resolve_call_path(&decorator.expression)
-        .and_then(|call_path| {
-            match call_path.as_slice() {
-                // MarkSafe
-                ["django", "utils", "safestring" | "html", "mark_safe"] => {
-                    Some(SuspiciousMarkSafeUsage.into())
-                }
-                _ => None,
-            }
-        })
-    else {
-        return;
-    };
-
-    let diagnostic = Diagnostic::new::<DiagnosticKind>(diagnostic_kind, decorator.range());
-    if checker.enabled(diagnostic.kind.rule()) {
-        checker.diagnostics.push(diagnostic);
-    }
-}

crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linter__rules__flake8_bandit__tests__S308_S308.py.snap

@@ -1,34 +0,0 @@
----
-source: crates/ruff_linter/src/rules/flake8_bandit/mod.rs
----
-S308.py:5:12: S308 Use of `mark_safe` may expose cross-site scripting vulnerabilities
-  |
-4 | def some_func():
-5 |     return mark_safe('<script>alert("evil!")</script>')
-  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ S308
-  |
-
-S308.py:8:1: S308 Use of `mark_safe` may expose cross-site scripting vulnerabilities
-   |
- 8 | @mark_safe
-   | ^^^^^^^^^^ S308
- 9 | def some_func():
-10 |     return '<script>alert("evil!")</script>'
-   |
-
-S308.py:17:12: S308 Use of `mark_safe` may expose cross-site scripting vulnerabilities
-   |
-16 | def some_func():
-17 |     return mark_safe('<script>alert("evil!")</script>')
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ S308
-   |
-
-S308.py:20:1: S308 Use of `mark_safe` may expose cross-site scripting vulnerabilities
-   |
-20 | @mark_safe
-   | ^^^^^^^^^^ S308
-21 | def some_func():
-22 |     return '<script>alert("evil!")</script>'
-   |
-
-

crates/ruff_linter/src/rules/flake8_blind_except/rules/blind_except.rs

@@ -83,7 +83,7 @@ pub(crate) fn blind_except(
         return;
     };
 
-    if !matches!(&**id, "BaseException" | "Exception") {
+    if !matches!(id.as_str(), "BaseException" | "Exception") {
         return;
     }
 
@@ -96,7 +96,7 @@ pub(crate) fn blind_except(
         if let Stmt::Raise(ast::StmtRaise { exc, .. }) = stmt {
             if let Some(exc) = exc {
                 if let Expr::Name(ast::ExprName { id, .. }) = exc.as_ref() {
-                    name.is_some_and(|name| &**id == name)
+                    name.is_some_and(|name| id == name)
                 } else {
                     false
                 }

crates/ruff_linter/src/rules/flake8_boolean_trap/helpers.rs

@@ -54,7 +54,7 @@ pub(super) fn is_allowed_func_def(name: &str) -> bool {
 pub(super) fn allow_boolean_trap(call: &ast::ExprCall) -> bool {
     let func_name = match call.func.as_ref() {
         Expr::Attribute(ast::ExprAttribute { attr, .. }) => attr.as_str(),
-        Expr::Name(ast::ExprName { id, .. }) => &**id,
+        Expr::Name(ast::ExprName { id, .. }) => id.as_str(),
         _ => return false,
     };
 

crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_type_hint_positional_argument.rs

@@ -164,7 +164,7 @@ pub(crate) fn boolean_type_hint_positional_argument(
 fn match_annotation_to_literal_bool(annotation: &Expr) -> bool {
     match annotation {
         // Ex) `True`
-        Expr::Name(name) => &*name.id == "bool",
+        Expr::Name(name) => &name.id == "bool",
         // Ex) `"True"`
         Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value == "bool",
         _ => false,
@@ -176,7 +176,7 @@ fn match_annotation_to_literal_bool(annotation: &Expr) -> bool {
 fn match_annotation_to_complex_bool(annotation: &Expr, semantic: &SemanticModel) -> bool {
     match annotation {
         // Ex) `bool`
-        Expr::Name(name) => &*name.id == "bool",
+        Expr::Name(name) => &name.id == "bool",
         // Ex) `"bool"`
         Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value == "bool",
         // Ex) `bool | int`

crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs

@@ -57,15 +57,15 @@ fn assertion_error(msg: Option<&Expr>) -> Stmt {
                 ctx: ExprContext::Load,
                 range: TextRange::default(),
             })),
-            arguments: Box::new(Arguments {
+            arguments: Arguments {
                 args: if let Some(msg) = msg {
-                    Box::from([msg.clone()])
+                    vec![msg.clone()]
                 } else {
-                    Box::from([])
+                    vec![]
                 },
-                keywords: Box::from([]),
+                keywords: vec![],
                 range: TextRange::default(),
-            }),
+            },
             range: TextRange::default(),
         }))),
         cause: None,

crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_raises_exception.rs

@@ -91,7 +91,7 @@ pub(crate) fn assert_raises_exception(checker: &mut Checker, items: &[WithItem])
             return;
         }
 
-        let [arg] = &*arguments.args else {
+        let [arg] = arguments.args.as_slice() else {
             return;
         };
 

crates/ruff_linter/src/rules/flake8_bugbear/rules/assignment_to_os_environ.rs

@@ -63,7 +63,7 @@ pub(crate) fn assignment_to_os_environ(checker: &mut Checker, targets: &[Expr])
     let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() else {
         return;
     };
-    if &**id != "os" {
+    if id != "os" {
         return;
     }
     checker

crates/ruff_linter/src/rules/flake8_bugbear/rules/cached_instance_method.rs

@@ -85,7 +85,7 @@ pub(crate) fn cached_instance_method(checker: &mut Checker, decorator_list: &[De
         // TODO(charlie): This should take into account `classmethod-decorators` and
         // `staticmethod-decorators`.
         if let Expr::Name(ast::ExprName { id, .. }) = &decorator.expression {
-            if &**id == "classmethod" || &**id == "staticmethod" {
+            if id == "classmethod" || id == "staticmethod" {
                 return;
             }
         }

crates/ruff_linter/src/rules/flake8_bugbear/rules/function_uses_loop_variable.rs

@@ -3,7 +3,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Node;
 use ruff_python_ast::visitor;
 use ruff_python_ast::visitor::Visitor;
-use ruff_python_ast::{self as ast, Comprehension, Expr, ExprContext, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Comprehension, Expr, ExprContext, Stmt};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -126,13 +126,18 @@ impl<'a> Visitor<'a> for SuspiciousVariablesVisitor<'a> {
         match expr {
             Expr::Call(ast::ExprCall {
                 func,
-                arguments,
+                arguments:
+                    Arguments {
+                        args,
+                        keywords,
+                        range: _,
+                    },
                 range: _,
             }) => {
                 match func.as_ref() {
                     Expr::Name(ast::ExprName { id, .. }) => {
-                        if matches!(&**id, "filter" | "reduce" | "map") {
-                            for arg in arguments.args.iter() {
+                        if matches!(id.as_str(), "filter" | "reduce" | "map") {
+                            for arg in args {
                                 if arg.is_lambda_expr() {
                                     self.safe_functions.push(arg);
                                 }
@@ -142,8 +147,8 @@ impl<'a> Visitor<'a> for SuspiciousVariablesVisitor<'a> {
                     Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                         if attr == "reduce" {
                             if let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() {
-                                if &**id == "functools" {
-                                    for arg in arguments.args.iter() {
+                                if id == "functools" {
+                                    for arg in args {
                                         if arg.is_lambda_expr() {
                                             self.safe_functions.push(arg);
                                         }
@@ -155,7 +160,7 @@ impl<'a> Visitor<'a> for SuspiciousVariablesVisitor<'a> {
                     _ => {}
                 }
 
-                for keyword in arguments.keywords.iter() {
+                for keyword in keywords {
                     if keyword.arg.as_ref().is_some_and(|arg| arg == "key")
                         && keyword.value.is_lambda_expr()
                     {
@@ -209,7 +214,7 @@ impl<'a> Visitor<'a> for NamesFromAssignmentsVisitor<'a> {
     fn visit_expr(&mut self, expr: &'a Expr) {
         match expr {
             Expr::Name(ast::ExprName { id, .. }) => {
-                self.names.push(id);
+                self.names.push(id.as_str());
             }
             Expr::Starred(ast::ExprStarred { value, .. }) => {
                 self.visit_expr(value);
@@ -303,7 +308,7 @@ pub(crate) fn function_uses_loop_variable(checker: &mut Checker, node: &Node) {
         // If a variable was used in a function or lambda body, and assigned in the
         // loop, flag it.
         for name in suspicious_variables {
-            if reassigned_in_loop.contains(&&*name.id) {
+            if reassigned_in_loop.contains(&name.id.as_str()) {
                 if !checker.flake8_bugbear_seen.contains(&name.range()) {
                     checker.flake8_bugbear_seen.push(name.range());
                     checker.diagnostics.push(Diagnostic::new(

crates/ruff_linter/src/rules/flake8_bugbear/rules/getattr_with_constant.rs

@@ -57,7 +57,7 @@ pub(crate) fn getattr_with_constant(
     let Expr::Name(ast::ExprName { id, .. }) = func else {
         return;
     };
-    if &**id != "getattr" {
+    if id != "getattr" {
         return;
     }
     let [obj, arg] = args else {

crates/ruff_linter/src/rules/flake8_bugbear/rules/raise_without_from_inside_except.rs

@@ -87,7 +87,7 @@ pub(crate) fn raise_without_from_inside_except(
                 if let Some(name) = name {
                     if exc
                         .as_name_expr()
-                        .is_some_and(|ast::ExprName { id, .. }| &**id == name)
+                        .is_some_and(|ast::ExprName { id, .. }| name == id)
                     {
                         continue;
                     }

crates/ruff_linter/src/rules/flake8_bugbear/rules/reuse_of_groupby_generator.rs

@@ -83,7 +83,7 @@ impl<'a> GroupNameFinder<'a> {
 
     fn name_matches(&self, expr: &Expr) -> bool {
         if let Expr::Name(ast::ExprName { id, .. }) = expr {
-            &**id == self.group_name
+            id == self.group_name
         } else {
             false
         }

crates/ruff_linter/src/rules/flake8_bugbear/rules/setattr_with_constant.rs

@@ -71,7 +71,7 @@ pub(crate) fn setattr_with_constant(
     let Expr::Name(ast::ExprName { id, .. }) = func else {
         return;
     };
-    if &**id != "setattr" {
+    if id != "setattr" {
         return;
     }
     let [obj, name, value] = args else {

crates/ruff_linter/src/rules/flake8_bugbear/rules/static_key_dict_comprehension.rs

@@ -73,7 +73,7 @@ pub(crate) fn static_key_dict_comprehension(checker: &mut Checker, dict_comp: &a
 fn is_constant(key: &Expr, names: &FxHashMap<&str, &ast::ExprName>) -> bool {
     match key {
         Expr::Tuple(ast::ExprTuple { elts, .. }) => elts.iter().all(|elt| is_constant(elt, names)),
-        Expr::Name(ast::ExprName { id, .. }) => !names.contains_key(&**id),
+        Expr::Name(ast::ExprName { id, .. }) => !names.contains_key(id.as_str()),
         Expr::Attribute(ast::ExprAttribute { value, .. }) => is_constant(value, names),
         Expr::Subscript(ast::ExprSubscript { value, slice, .. }) => {
             is_constant(value, names) && is_constant(slice, names)

crates/ruff_linter/src/rules/flake8_bugbear/rules/unintentional_type_annotation.rs

@@ -54,7 +54,7 @@ pub(crate) fn unintentional_type_annotation(
         }
         Expr::Attribute(ast::ExprAttribute { value, .. }) => {
             if let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() {
-                if &**id != "self" {
+                if id != "self" {
                     checker
                         .diagnostics
                         .push(Diagnostic::new(UnintentionalTypeAnnotation, stmt.range()));

crates/ruff_linter/src/rules/flake8_bugbear/rules/unreliable_callable_check.rs

@@ -61,7 +61,7 @@ pub(crate) fn unreliable_callable_check(
     let Expr::Name(ast::ExprName { id, .. }) = func else {
         return;
     };
-    if !matches!(&**id, "hasattr" | "getattr") {
+    if !matches!(id.as_str(), "hasattr" | "getattr") {
         return;
     }
     let [obj, attr, ..] = args else {
@@ -75,7 +75,7 @@ pub(crate) fn unreliable_callable_check(
     }
 
     let mut diagnostic = Diagnostic::new(UnreliableCallableCheck, expr.range());
-    if &**id == "hasattr" {
+    if id == "hasattr" {
         if checker.semantic().is_builtin("callable") {
             diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
                 format!("callable({})", checker.locator().slice(obj)),

crates/ruff_linter/src/rules/flake8_bugbear/rules/zip_without_explicit_strict.rs

@@ -1,7 +1,7 @@
 use ruff_diagnostics::{AlwaysFixableViolation, Applicability, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Arguments, Expr};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
 
@@ -53,7 +53,7 @@ impl AlwaysFixableViolation for ZipWithoutExplicitStrict {
 /// B905
 pub(crate) fn zip_without_explicit_strict(checker: &mut Checker, call: &ast::ExprCall) {
     if let Expr::Name(ast::ExprName { id, .. }) = call.func.as_ref() {
-        if &**id == "zip"
+        if id == "zip"
             && checker.semantic().is_builtin("zip")
             && call.arguments.find_keyword("strict").is_none()
             && !call
@@ -91,7 +91,9 @@ pub(crate) fn zip_without_explicit_strict(checker: &mut Checker, call: &ast::Exp
 /// `itertools.cycle` or similar).
 fn is_infinite_iterator(arg: &Expr, semantic: &SemanticModel) -> bool {
     let Expr::Call(ast::ExprCall {
-        func, arguments, ..
+        func,
+        arguments: Arguments { args, keywords, .. },
+        ..
     }) = &arg
     else {
         return false;
@@ -102,17 +104,17 @@ fn is_infinite_iterator(arg: &Expr, semantic: &SemanticModel) -> bool {
             ["itertools", "cycle" | "count"] => true,
             ["itertools", "repeat"] => {
                 // Ex) `itertools.repeat(1)`
-                if arguments.keywords.is_empty() && arguments.args.len() == 1 {
+                if keywords.is_empty() && args.len() == 1 {
                     return true;
                 }
 
                 // Ex) `itertools.repeat(1, None)`
-                if arguments.args.len() == 2 && arguments.args[1].is_none_literal_expr() {
+                if args.len() == 2 && args[1].is_none_literal_expr() {
                     return true;
                 }
 
                 // Ex) `iterools.repeat(1, times=None)`
-                for keyword in arguments.keywords.iter() {
+                for keyword in keywords {
                     if keyword.arg.as_ref().is_some_and(|name| name == "times") {
                         if keyword.value.is_none_literal_expr() {
                             return true;

crates/ruff_linter/src/rules/flake8_commas/rules/trailing_commas.rs

@@ -1,8 +1,10 @@
+use itertools::Itertools;
+
 use ruff_diagnostics::{AlwaysFixableViolation, Violation};
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_index::Indexer;
-use ruff_python_parser::lexer::LexResult;
+use ruff_python_parser::lexer::{LexResult, Spanned};
 use ruff_python_parser::Tok;
 use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextRange};
@@ -10,20 +12,20 @@ use ruff_text_size::{Ranged, TextRange};
 /// Simplified token type.
 #[derive(Copy, Clone, PartialEq, Eq)]
 enum TokenType {
-    Named,
-    String,
-    Newline,
-    NonLogicalNewline,
-    OpeningBracket,
-    ClosingBracket,
-    OpeningSquareBracket,
-    Colon,
-    Comma,
-    OpeningCurlyBracket,
-    Def,
-    For,
-    Lambda,
     Irrelevant,
+    NonLogicalNewline,
+    Newline,
+    Comma,
+    OpeningBracket,
+    OpeningSquareBracket,
+    OpeningCurlyBracket,
+    ClosingBracket,
+    For,
+    Named,
+    Def,
+    Lambda,
+    Colon,
+    String,
 }
 
 /// Simplified token specialized for the task.
@@ -52,30 +54,30 @@ impl Token {
     }
 }
 
-impl From<(&Tok, TextRange)> for Token {
-    fn from((tok, range): (&Tok, TextRange)) -> Self {
-        let r#type = match tok {
-            Tok::Name { .. } => TokenType::Named,
-            Tok::String { .. } => TokenType::String,
-            Tok::Newline => TokenType::Newline,
+impl From<&Spanned> for Token {
+    fn from(spanned: &Spanned) -> Self {
+        let r#type = match &spanned.0 {
             Tok::NonLogicalNewline => TokenType::NonLogicalNewline,
-            Tok::Lpar => TokenType::OpeningBracket,
-            Tok::Rpar => TokenType::ClosingBracket,
-            Tok::Lsqb => TokenType::OpeningSquareBracket,
-            Tok::Rsqb => TokenType::ClosingBracket,
-            Tok::Colon => TokenType::Colon,
-            Tok::Comma => TokenType::Comma,
-            Tok::Lbrace => TokenType::OpeningCurlyBracket,
-            Tok::Rbrace => TokenType::ClosingBracket,
-            Tok::Def => TokenType::Def,
+            Tok::Newline => TokenType::Newline,
             Tok::For => TokenType::For,
+            Tok::Def => TokenType::Def,
             Tok::Lambda => TokenType::Lambda,
             // Import treated like a function.
             Tok::Import => TokenType::Named,
+            Tok::Name { .. } => TokenType::Named,
+            Tok::String { .. } => TokenType::String,
+            Tok::Comma => TokenType::Comma,
+            Tok::Lpar => TokenType::OpeningBracket,
+            Tok::Lsqb => TokenType::OpeningSquareBracket,
+            Tok::Lbrace => TokenType::OpeningCurlyBracket,
+            Tok::Rpar | Tok::Rsqb | Tok::Rbrace => TokenType::ClosingBracket,
+            Tok::Colon => TokenType::Colon,
             _ => TokenType::Irrelevant,
         };
-        #[allow(clippy::inconsistent_struct_constructor)]
-        Self { range, r#type }
+        Self {
+            range: spanned.1,
+            r#type,
+        }
     }
 }
 
@@ -235,12 +237,10 @@ pub(crate) fn trailing_commas(
     indexer: &Indexer,
 ) {
     let mut fstrings = 0u32;
-    let tokens = tokens.iter().filter_map(|result| {
-        let Ok((tok, tok_range)) = result else {
-            return None;
-        };
-
-        match tok {
+    let tokens = tokens
+        .iter()
+        .flatten()
+        .filter_map(|spanned @ (tok, tok_range)| match tok {
             // Completely ignore comments -- they just interfere with the logic.
             Tok::Comment(_) => None,
             // F-strings are handled as `String` token type with the complete range
@@ -263,30 +263,69 @@ pub(crate) fn trailing_commas(
             }
             _ => {
                 if fstrings == 0 {
-                    Some(Token::from((tok, *tok_range)))
+                    Some(Token::from(spanned))
                 } else {
                     None
                 }
             }
+        });
+    let tokens = [Token::irrelevant(), Token::irrelevant()]
+        .into_iter()
+        .chain(tokens);
+    // Collapse consecutive newlines to the first one -- trailing commas are
+    // added before the first newline.
+    let tokens = tokens.coalesce(|previous, current| {
+        if previous.r#type == TokenType::NonLogicalNewline
+            && current.r#type == TokenType::NonLogicalNewline
+        {
+            Ok(previous)
+        } else {
+            Err((previous, current))
         }
     });
 
-    let mut prev = Token::irrelevant();
-    let mut prev_prev = Token::irrelevant();
-
+    // The current nesting of the comma contexts.
     let mut stack = vec![Context::new(ContextType::No)];
 
-    for token in tokens {
-        if prev.r#type == TokenType::NonLogicalNewline
-            && token.r#type == TokenType::NonLogicalNewline
-        {
-            // Collapse consecutive newlines to the first one -- trailing commas are
-            // added before the first newline.
-            continue;
-        }
-
+    for (prev_prev, prev, token) in tokens.tuple_windows() {
         // Update the comma context stack.
-        let context = update_context(token, prev, prev_prev, &mut stack);
+        match token.r#type {
+            TokenType::OpeningBracket => match (prev.r#type, prev_prev.r#type) {
+                (TokenType::Named, TokenType::Def) => {
+                    stack.push(Context::new(ContextType::FunctionParameters));
+                }
+                (TokenType::Named | TokenType::ClosingBracket, _) => {
+                    stack.push(Context::new(ContextType::CallArguments));
+                }
+                _ => {
+                    stack.push(Context::new(ContextType::Tuple));
+                }
+            },
+            TokenType::OpeningSquareBracket => match prev.r#type {
+                TokenType::ClosingBracket | TokenType::Named | TokenType::String => {
+                    stack.push(Context::new(ContextType::Subscript));
+                }
+                _ => {
+                    stack.push(Context::new(ContextType::List));
+                }
+            },
+            TokenType::OpeningCurlyBracket => {
+                stack.push(Context::new(ContextType::Dict));
+            }
+            TokenType::Lambda => {
+                stack.push(Context::new(ContextType::LambdaParameters));
+            }
+            TokenType::For => {
+                let len = stack.len();
+                stack[len - 1] = Context::new(ContextType::No);
+            }
+            TokenType::Comma => {
+                let len = stack.len();
+                stack[len - 1].inc();
+            }
+            _ => {}
+        }
+        let context = &stack[stack.len() - 1];
 
         // Is it allowed to have a trailing comma before this token?
         let comma_allowed = token.r#type == TokenType::ClosingBracket
@@ -373,47 +412,5 @@ pub(crate) fn trailing_commas(
         if pop_context && stack.len() > 1 {
             stack.pop();
         }
-
-        prev_prev = prev;
-        prev = token;
     }
 }
-
-fn update_context(
-    token: Token,
-    prev: Token,
-    prev_prev: Token,
-    stack: &mut Vec<Context>,
-) -> Context {
-    let new_context = match token.r#type {
-        TokenType::OpeningBracket => match (prev.r#type, prev_prev.r#type) {
-            (TokenType::Named, TokenType::Def) => Context::new(ContextType::FunctionParameters),
-            (TokenType::Named | TokenType::ClosingBracket, _) => {
-                Context::new(ContextType::CallArguments)
-            }
-            _ => Context::new(ContextType::Tuple),
-        },
-        TokenType::OpeningSquareBracket => match prev.r#type {
-            TokenType::ClosingBracket | TokenType::Named | TokenType::String => {
-                Context::new(ContextType::Subscript)
-            }
-            _ => Context::new(ContextType::List),
-        },
-        TokenType::OpeningCurlyBracket => Context::new(ContextType::Dict),
-        TokenType::Lambda => Context::new(ContextType::LambdaParameters),
-        TokenType::For => {
-            let last = stack.last_mut().expect("Stack to never be empty");
-            *last = Context::new(ContextType::No);
-            return *last;
-        }
-        TokenType::Comma => {
-            let last = stack.last_mut().expect("Stack to never be empty");
-            last.inc();
-            return *last;
-        }
-        _ => return stack.last().copied().expect("Stack to never be empty"),
-    };
-
-    stack.push(new_context);
-    new_context
-}

crates/ruff_linter/src/rules/flake8_comprehensions/rules/helpers.rs

@@ -13,7 +13,7 @@ pub(super) fn exactly_one_argument_with_matching_function<'a>(
         return None;
     }
     let func = func.as_name_expr()?;
-    if &*func.id != name {
+    if func.id != name {
         return None;
     }
     Some(arg)
@@ -24,7 +24,7 @@ pub(super) fn first_argument_with_matching_function<'a>(
     func: &Expr,
     args: &'a [Expr],
 ) -> Option<&'a Expr> {
-    if func.as_name_expr().is_some_and(|func| &*func.id == name) {
+    if func.as_name_expr().is_some_and(|func| func.id == name) {
         args.first()
     } else {
         None

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_call_around_sorted.rs

@@ -66,7 +66,7 @@ pub(crate) fn unnecessary_call_around_sorted(
     let Some(outer) = func.as_name_expr() else {
         return;
     };
-    if !matches!(&*outer.id, "list" | "reversed") {
+    if !matches!(outer.id.as_str(), "list" | "reversed") {
         return;
     }
     let Some(arg) = args.first() else {
@@ -78,7 +78,7 @@ pub(crate) fn unnecessary_call_around_sorted(
     let Some(inner) = func.as_name_expr() else {
         return;
     };
-    if &*inner.id != "sorted" {
+    if inner.id != "sorted" {
         return;
     }
     if !checker.semantic().is_builtin(&inner.id) || !checker.semantic().is_builtin(&outer.id) {
@@ -93,7 +93,7 @@ pub(crate) fn unnecessary_call_around_sorted(
     diagnostic.try_set_fix(|| {
         Ok(Fix::applicable_edit(
             fixes::fix_unnecessary_call_around_sorted(expr, checker.locator(), checker.stylist())?,
-            if &*outer.id == "reversed" {
+            if outer.id == "reversed" {
                 Applicability::Unsafe
             } else {
                 Applicability::Safe

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_collection_call.rs

@@ -68,7 +68,7 @@ pub(crate) fn unnecessary_collection_call(
     let Some(func) = call.func.as_name_expr() else {
         return;
     };
-    let collection = match &*func.id {
+    let collection = match func.id.as_str() {
         "dict"
             if call.arguments.keywords.is_empty()
                 || (!settings.allow_dict_calls_with_keyword_arguments
@@ -87,7 +87,7 @@ pub(crate) fn unnecessary_collection_call(
         }
         _ => return,
     };
-    if !checker.semantic().is_builtin(&func.id) {
+    if !checker.semantic().is_builtin(func.id.as_str()) {
         return;
     }
 

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_comprehension_any_all.rs

@@ -75,7 +75,7 @@ pub(crate) fn unnecessary_comprehension_any_all(
     let Expr::Name(ast::ExprName { id, .. }) = func else {
         return;
     };
-    if !matches!(&**id, "all" | "any") {
+    if !matches!(id.as_str(), "all" | "any") {
         return;
     }
     let [arg] = args else {

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_double_cast_or_process.rs

@@ -1,7 +1,7 @@
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::comparable::ComparableKeyword;
-use ruff_python_ast::{self as ast, Expr, Keyword};
+use ruff_python_ast::{self as ast, Arguments, Expr, Keyword};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -77,14 +77,21 @@ pub(crate) fn unnecessary_double_cast_or_process(
     let Some(outer) = func.as_name_expr() else {
         return;
     };
-    if !matches!(&*outer.id, "list" | "tuple" | "set" | "reversed" | "sorted") {
+    if !matches!(
+        outer.id.as_str(),
+        "list" | "tuple" | "set" | "reversed" | "sorted"
+    ) {
         return;
     }
     let Some(arg) = args.first() else {
         return;
     };
     let Expr::Call(ast::ExprCall {
-        func, arguments, ..
+        func,
+        arguments: Arguments {
+            keywords: inner_kw, ..
+        },
+        ..
     }) = arg
     else {
         return;
@@ -98,11 +105,11 @@ pub(crate) fn unnecessary_double_cast_or_process(
 
     // Avoid collapsing nested `sorted` calls with non-identical keyword arguments
     // (i.e., `key`, `reverse`).
-    if &*inner.id == "sorted" && &*outer.id == "sorted" {
-        if arguments.keywords.len() != outer_kw.len() {
+    if inner.id == "sorted" && outer.id == "sorted" {
+        if inner_kw.len() != outer_kw.len() {
             return;
         }
-        if !arguments.keywords.iter().all(|inner| {
+        if !inner_kw.iter().all(|inner| {
             outer_kw
                 .iter()
                 .any(|outer| ComparableKeyword::from(inner) == ComparableKeyword::from(outer))
@@ -115,7 +122,7 @@ pub(crate) fn unnecessary_double_cast_or_process(
     // Ex) `list(tuple(...))`
     // Ex) `set(set(...))`
     if matches!(
-        (&*outer.id, &*inner.id),
+        (outer.id.as_str(), inner.id.as_str()),
         ("set" | "sorted", "list" | "tuple" | "reversed" | "sorted")
             | ("set", "set")
             | ("list" | "tuple", "list" | "tuple")

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_map.rs

@@ -5,7 +5,7 @@ use ruff_diagnostics::{FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::visitor;
 use ruff_python_ast::visitor::Visitor;
-use ruff_python_ast::{self as ast, Expr, ExprContext, Parameters, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Expr, ExprContext, Parameters, Stmt};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -77,7 +77,7 @@ pub(crate) fn unnecessary_map(
         return;
     };
 
-    let object_type = match &*func.id {
+    let object_type = match func.id.as_str() {
         "map" => ObjectType::Generator,
         "list" => ObjectType::List,
         "set" => ObjectType::Set,
@@ -95,7 +95,7 @@ pub(crate) fn unnecessary_map(
             if parent
                 .and_then(Expr::as_call_expr)
                 .and_then(|call| call.func.as_name_expr())
-                .is_some_and(|name| matches!(&*name.id, "list" | "set" | "dict"))
+                .is_some_and(|name| matches!(name.id.as_str(), "list" | "set" | "dict"))
             {
                 return;
             }
@@ -125,22 +125,23 @@ pub(crate) fn unnecessary_map(
         ObjectType::List | ObjectType::Set => {
             // Only flag, e.g., `list(map(lambda x: x + 1, iterable))`.
             let [Expr::Call(ast::ExprCall {
-                func, arguments, ..
+                func,
+                arguments: Arguments { args, keywords, .. },
+                ..
             })] = args
             else {
                 return;
             };
 
-            if arguments.args.len() != 2 {
+            if args.len() != 2 {
                 return;
             }
 
-            if !arguments.keywords.is_empty() {
+            if !keywords.is_empty() {
                 return;
             }
 
-            let Some(argument) =
-                helpers::first_argument_with_matching_function("map", func, &arguments.args)
+            let Some(argument) = helpers::first_argument_with_matching_function("map", func, args)
             else {
                 return;
             };
@@ -169,22 +170,23 @@ pub(crate) fn unnecessary_map(
         ObjectType::Dict => {
             // Only flag, e.g., `dict(map(lambda v: (v, v ** 2), values))`.
             let [Expr::Call(ast::ExprCall {
-                func, arguments, ..
+                func,
+                arguments: Arguments { args, keywords, .. },
+                ..
             })] = args
             else {
                 return;
             };
 
-            if arguments.args.len() != 2 {
+            if args.len() != 2 {
                 return;
             }
 
-            if !arguments.keywords.is_empty() {
+            if !keywords.is_empty() {
                 return;
             }
 
-            let Some(argument) =
-                helpers::first_argument_with_matching_function("map", func, &arguments.args)
+            let Some(argument) = helpers::first_argument_with_matching_function("map", func, args)
             else {
                 return;
             };

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_subscript_reversal.rs

@@ -47,7 +47,7 @@ pub(crate) fn unnecessary_subscript_reversal(checker: &mut Checker, call: &ast::
     let Some(func) = call.func.as_name_expr() else {
         return;
     };
-    if !matches!(&*func.id, "reversed" | "set" | "sorted") {
+    if !matches!(func.id.as_str(), "reversed" | "set" | "sorted") {
         return;
     }
     if !checker.semantic().is_builtin(&func.id) {

crates/ruff_linter/src/rules/flake8_django/rules/all_with_model_form.rs

@@ -72,7 +72,7 @@ pub(crate) fn all_with_model_form(checker: &mut Checker, class_def: &ast::StmtCl
                 let Expr::Name(ast::ExprName { id, .. }) = target else {
                     continue;
                 };
-                if &**id != "fields" {
+                if id != "fields" {
                     continue;
                 }
                 match value.as_ref() {

crates/ruff_linter/src/rules/flake8_django/rules/exclude_with_model_form.rs

@@ -70,7 +70,7 @@ pub(crate) fn exclude_with_model_form(checker: &mut Checker, class_def: &ast::St
                 let Expr::Name(ast::ExprName { id, .. }) = target else {
                     continue;
                 };
-                if &**id == "exclude" {
+                if id == "exclude" {
                     checker
                         .diagnostics
                         .push(Diagnostic::new(DjangoExcludeWithModelForm, target.range()));

crates/ruff_linter/src/rules/flake8_django/rules/model_without_dunder_str.rs

@@ -106,7 +106,7 @@ fn is_model_abstract(class_def: &ast::StmtClassDef) -> bool {
                 let Expr::Name(ast::ExprName { id, .. }) = target else {
                     continue;
                 };
-                if &**id != "abstract" {
+                if id != "abstract" {
                     continue;
                 }
                 if !is_const_true(value) {

crates/ruff_linter/src/rules/flake8_django/rules/nullable_model_string_field.rs

@@ -88,7 +88,7 @@ fn is_nullable_field<'a>(value: &'a Expr, semantic: &'a SemanticModel) -> Option
     let mut null_key = false;
     let mut blank_key = false;
     let mut unique_key = false;
-    for keyword in call.arguments.keywords.iter() {
+    for keyword in &call.arguments.keywords {
         let Some(argument) = &keyword.arg else {
             continue;
         };

crates/ruff_linter/src/rules/flake8_django/rules/unordered_body_content_in_model.rs

@@ -165,7 +165,7 @@ fn get_element_type(element: &Stmt, semantic: &SemanticModel) -> Option<ContentT
             let Expr::Name(ast::ExprName { id, .. }) = expr else {
                 return None;
             };
-            if &**id == "objects" {
+            if id == "objects" {
                 Some(ContentType::ManagerDeclaration)
             } else {
                 None

crates/ruff_linter/src/rules/flake8_errmsg/rules/string_in_exception.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Expr, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Expr, Stmt};
 use ruff_source_file::Locator;
 use ruff_text_size::Ranged;
 
@@ -175,8 +175,12 @@ impl Violation for DotFormatInException {
 
 /// EM101, EM102, EM103
 pub(crate) fn string_in_exception(checker: &mut Checker, stmt: &Stmt, exc: &Expr) {
-    if let Expr::Call(ast::ExprCall { arguments, .. }) = exc {
-        if let Some(first) = arguments.args.first() {
+    if let Expr::Call(ast::ExprCall {
+        arguments: Arguments { args, .. },
+        ..
+    }) = exc
+    {
+        if let Some(first) = args.first() {
             match first {
                 // Check for string literals.
                 Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => {

crates/ruff_linter/src/rules/flake8_gettext/mod.rs

@@ -7,7 +7,7 @@ pub mod settings;
 /// Returns true if the [`Expr`] is an internationalization function call.
 pub(crate) fn is_gettext_func_call(func: &Expr, functions_names: &[String]) -> bool {
     if let Expr::Name(ast::ExprName { id, .. }) = func {
-        functions_names.iter().any(|name| name == &**id)
+        functions_names.contains(id)
     } else {
         false
     }

crates/ruff_linter/src/rules/flake8_implicit_str_concat/rules/implicit.rs

@@ -5,7 +5,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::str::{leading_quote, trailing_quote};
 use ruff_python_index::Indexer;
 use ruff_python_parser::lexer::LexResult;
-use ruff_python_parser::Tok;
+use ruff_python_parser::TokenKind;
 use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextRange};
 
@@ -101,28 +101,37 @@ pub(crate) fn implicit(
     for ((a_tok, a_range), (b_tok, b_range)) in tokens
         .iter()
         .flatten()
-        .filter(|(tok, _)| {
-            !tok.is_comment()
-                && (settings.flake8_implicit_str_concat.allow_multiline
-                    || !tok.is_non_logical_newline())
+        .filter_map(|(tok, range)| {
+            // Ignore comments.
+            if tok.is_comment() {
+                return None;
+            }
+
+            // Ignore non-localized newlines.
+            if !settings.flake8_implicit_str_concat.allow_multiline && tok.is_non_logical_newline()
+            {
+                return None;
+            }
+
+            Some((TokenKind::from(tok), *range))
         })
         .tuple_windows()
     {
         let (a_range, b_range) = match (a_tok, b_tok) {
-            (Tok::String { .. }, Tok::String { .. }) => (*a_range, *b_range),
-            (Tok::String { .. }, Tok::FStringStart) => {
+            (TokenKind::String, TokenKind::String) => (a_range, b_range),
+            (TokenKind::String, TokenKind::FStringStart) => {
                 match indexer.fstring_ranges().innermost(b_range.start()) {
-                    Some(b_range) => (*a_range, b_range),
+                    Some(b_range) => (a_range, b_range),
                     None => continue,
                 }
             }
-            (Tok::FStringEnd, Tok::String { .. }) => {
+            (TokenKind::FStringEnd, TokenKind::String { .. }) => {
                 match indexer.fstring_ranges().innermost(a_range.start()) {
-                    Some(a_range) => (a_range, *b_range),
+                    Some(a_range) => (a_range, b_range),
                     None => continue,
                 }
             }
-            (Tok::FStringEnd, Tok::FStringStart) => {
+            (TokenKind::FStringEnd, TokenKind::FStringStart) => {
                 match (
                     indexer.fstring_ranges().innermost(a_range.start()),
                     indexer.fstring_ranges().innermost(b_range.start()),

crates/ruff_linter/src/rules/flake8_logging_format/rules/logging_call.rs

@@ -1,5 +1,5 @@
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
-use ruff_python_ast::{self as ast, Expr, Keyword, Operator};
+use ruff_python_ast::{self as ast, Arguments, Expr, Keyword, Operator};
 use ruff_python_semantic::analyze::logging;
 use ruff_python_stdlib::logging::LoggingLevel;
 use ruff_text_size::Ranged;
@@ -90,7 +90,7 @@ fn check_msg(checker: &mut Checker, msg: &Expr) {
 fn check_log_record_attr_clash(checker: &mut Checker, extra: &Keyword) {
     match &extra.value {
         Expr::Dict(ast::ExprDict { keys, .. }) => {
-            for key in keys.iter() {
+            for key in keys {
                 if let Some(key) = &key {
                     if let Expr::StringLiteral(ast::ExprStringLiteral { value: attr, .. }) = key {
                         if is_reserved_attr(attr.to_str()) {
@@ -104,14 +104,16 @@ fn check_log_record_attr_clash(checker: &mut Checker, extra: &Keyword) {
             }
         }
         Expr::Call(ast::ExprCall {
-            func, arguments, ..
+            func,
+            arguments: Arguments { keywords, .. },
+            ..
         }) => {
             if checker
                 .semantic()
                 .resolve_call_path(func)
                 .is_some_and(|call_path| matches!(call_path.as_slice(), ["", "dict"]))
             {
-                for keyword in arguments.keywords.iter() {
+                for keyword in keywords {
                     if let Some(attr) = &keyword.arg {
                         if is_reserved_attr(attr) {
                             checker.diagnostics.push(Diagnostic::new(

crates/ruff_linter/src/rules/flake8_pie/rules/duplicate_class_field_definition.rs

@@ -93,7 +93,7 @@ pub(crate) fn duplicate_class_field_definition(checker: &mut Checker, body: &[St
             _ => continue,
         }
 
-        if !seen_targets.insert(&*target.id) {
+        if !seen_targets.insert(target.id.as_str()) {
             let mut diagnostic = Diagnostic::new(
                 DuplicateClassFieldDefinition {
                     name: target.id.to_string(),

crates/ruff_linter/src/rules/flake8_pie/rules/multiple_starts_ends_with.rs

@@ -81,18 +81,23 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
     for (index, call) in values.iter().enumerate() {
         let Expr::Call(ast::ExprCall {
             func,
-            arguments,
+            arguments:
+                Arguments {
+                    args,
+                    keywords,
+                    range: _,
+                },
             range: _,
         }) = &call
         else {
             continue;
         };
 
-        if !arguments.keywords.is_empty() {
+        if !keywords.is_empty() {
             continue;
         }
 
-        let [arg] = &*arguments.args else {
+        let [arg] = args.as_slice() else {
             continue;
         };
 
@@ -115,7 +120,7 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
         }
 
         duplicates
-            .entry((&**attr, &**arg_name))
+            .entry((attr.as_str(), arg_name.as_str()))
             .or_insert_with(Vec::new)
             .push(index);
     }
@@ -135,7 +140,12 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
                 .map(|expr| {
                     let Expr::Call(ast::ExprCall {
                         func: _,
-                        arguments,
+                        arguments:
+                            Arguments {
+                                args,
+                                keywords: _,
+                                range: _,
+                            },
                         range: _,
                     }) = expr
                     else {
@@ -144,9 +154,7 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
                             format!("Indices should only contain `{attr_name}` calls")
                         )
                     };
-                    arguments
-                        .args
-                        .first()
+                    args.first()
                         .unwrap_or_else(|| panic!("`{attr_name}` should have one argument"))
                 })
                 .collect();
@@ -179,11 +187,11 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
             });
             let node3 = Expr::Call(ast::ExprCall {
                 func: Box::new(node2),
-                arguments: Box::new(Arguments {
-                    args: Box::from([node]),
-                    keywords: Box::from([]),
+                arguments: Arguments {
+                    args: vec![node],
+                    keywords: vec![],
                     range: TextRange::default(),
-                }),
+                },
                 range: TextRange::default(),
             });
             let call = node3;
@@ -221,7 +229,7 @@ fn is_bound_to_tuple(arg: &Expr, semantic: &SemanticModel) -> bool {
         return false;
     };
 
-    let Some(binding_id) = semantic.lookup_symbol(id) else {
+    let Some(binding_id) = semantic.lookup_symbol(id.as_str()) else {
         return false;
     };
 

crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_dict_kwargs.rs

@@ -59,7 +59,7 @@ impl Violation for UnnecessaryDictKwargs {
 /// PIE804
 pub(crate) fn unnecessary_dict_kwargs(checker: &mut Checker, call: &ast::ExprCall) {
     let mut duplicate_keywords = None;
-    for keyword in call.arguments.keywords.iter() {
+    for keyword in &call.arguments.keywords {
         // keyword is a spread operator (indicated by None).
         if keyword.arg.is_some() {
             continue;
@@ -70,7 +70,7 @@ pub(crate) fn unnecessary_dict_kwargs(checker: &mut Checker, call: &ast::ExprCal
         };
 
         // Ex) `foo(**{**bar})`
-        if matches!(&**keys, [None]) {
+        if matches!(keys.as_slice(), [None]) {
             let mut diagnostic = Diagnostic::new(UnnecessaryDictKwargs, keyword.range());
 
             diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
@@ -145,13 +145,13 @@ fn duplicates(call: &ast::ExprCall) -> FxHashSet<&str> {
         call.arguments.keywords.len(),
         BuildHasherDefault::default(),
     );
-    for keyword in call.arguments.keywords.iter() {
+    for keyword in &call.arguments.keywords {
         if let Some(name) = &keyword.arg {
             if !seen.insert(name.as_str()) {
                 duplicates.insert(name.as_str());
             }
         } else if let Expr::Dict(ast::ExprDict { keys, .. }) = &keyword.value {
-            for key in keys.iter() {
+            for key in keys {
                 if let Some(name) = key.as_ref().and_then(as_kwarg) {
                     if !seen.insert(name) {
                         duplicates.insert(name);

crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_range_start.rs

@@ -47,7 +47,7 @@ pub(crate) fn unnecessary_range_start(checker: &mut Checker, call: &ast::ExprCal
     let Expr::Name(ast::ExprName { id, .. }) = call.func.as_ref() else {
         return;
     };
-    if &**id != "range" {
+    if id != "range" {
         return;
     };
     if !checker.semantic().is_builtin("range") {
@@ -60,7 +60,7 @@ pub(crate) fn unnecessary_range_start(checker: &mut Checker, call: &ast::ExprCal
     }
 
     // Verify that the call has exactly two arguments (no `step`).
-    let [start, _] = &*call.arguments.args else {
+    let [start, _] = call.arguments.args.as_slice() else {
         return;
     };
 

crates/ruff_linter/src/rules/flake8_pyi/rules/bad_version_info_comparison.rs

@@ -69,7 +69,7 @@ pub(crate) fn bad_version_info_comparison(checker: &mut Checker, test: &Expr) {
         return;
     };
 
-    let ([op], [_right]) = (&**ops, &**comparators) else {
+    let ([op], [_right]) = (ops.as_slice(), comparators.as_slice()) else {
         return;
     };
 

crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_return_type.rs

@@ -142,7 +142,7 @@ fn class_method(
 
     // Don't error if the first argument is annotated with typing.Type[T].
     // These are edge cases, and it's hard to give good error messages for them.
-    if &*value.id != "type" {
+    if value.id != "type" {
         return false;
     };
 

crates/ruff_linter/src/rules/flake8_pyi/rules/non_self_return_type.rs

@@ -264,7 +264,7 @@ fn is_name(expr: &Expr, name: &str) -> bool {
     let Expr::Name(ast::ExprName { id, .. }) = expr else {
         return false;
     };
-    &**id == name
+    id.as_str() == name
 }
 
 /// Return `true` if the given expression resolves to `typing.Self`.

crates/ruff_linter/src/rules/flake8_pyi/rules/redundant_literal_union.rs

@@ -132,7 +132,7 @@ impl fmt::Display for ExprType {
 /// `str`, `bytes`, or `complex`).
 fn match_builtin_type(expr: &Expr, semantic: &SemanticModel) -> Option<ExprType> {
     let name = expr.as_name_expr()?;
-    let result = match &*name.id {
+    let result = match name.id.as_str() {
         "int" => ExprType::Int,
         "bool" => ExprType::Bool,
         "str" => ExprType::Str,
@@ -141,7 +141,7 @@ fn match_builtin_type(expr: &Expr, semantic: &SemanticModel) -> Option<ExprType>
         "complex" => ExprType::Complex,
         _ => return None,
     };
-    if !semantic.is_builtin(&name.id) {
+    if !semantic.is_builtin(name.id.as_str()) {
         return None;
     }
     Some(result)

crates/ruff_linter/src/rules/flake8_pyi/rules/simple_defaults.rs

@@ -307,7 +307,7 @@ fn is_valid_default_value_with_annotation(
         }) => {
             return allow_container
                 && keys.len() <= 10
-                && keys.iter().zip(values.iter()).all(|(k, v)| {
+                && keys.iter().zip(values).all(|(k, v)| {
                     k.as_ref().is_some_and(|k| {
                         is_valid_default_value_with_annotation(k, false, locator, semantic)
                     }) && is_valid_default_value_with_annotation(v, false, locator, semantic)
@@ -450,7 +450,7 @@ fn is_type_var_like_call(expr: &Expr, semantic: &SemanticModel) -> bool {
 /// `__all__`).
 fn is_special_assignment(target: &Expr, semantic: &SemanticModel) -> bool {
     if let Expr::Name(ast::ExprName { id, .. }) = target {
-        match &**id {
+        match id.as_str() {
             "__all__" => semantic.current_scope().kind.is_module(),
             "__match_args__" | "__slots__" => semantic.current_scope().kind.is_class(),
             _ => false,

crates/ruff_linter/src/rules/flake8_pyi/rules/unnecessary_type_union.rs

@@ -122,7 +122,7 @@ pub(crate) fn unnecessary_type_union<'a>(checker: &mut Checker, union: &'a Expr)
                                 .into_iter()
                                 .map(|type_member| {
                                     Expr::Name(ast::ExprName {
-                                        id: type_member.into_boxed_str(),
+                                        id: type_member,
                                         ctx: ExprContext::Load,
                                         range: TextRange::default(),
                                     })

crates/ruff_linter/src/rules/flake8_pyi/rules/unrecognized_platform.rs

@@ -101,7 +101,7 @@ pub(crate) fn unrecognized_platform(checker: &mut Checker, test: &Expr) {
         return;
     };
 
-    let ([op], [right]) = (&**ops, &**comparators) else {
+    let ([op], [right]) = (ops.as_slice(), comparators.as_slice()) else {
         return;
     };
 

crates/ruff_linter/src/rules/flake8_pyi/rules/unrecognized_version_info.rs

@@ -129,7 +129,7 @@ pub(crate) fn unrecognized_version_info(checker: &mut Checker, test: &Expr) {
         return;
     };
 
-    let ([op], [comparator]) = (&**ops, &**comparators) else {
+    let ([op], [comparator]) = (ops.as_slice(), comparators.as_slice()) else {
         return;
     };
 

crates/ruff_linter/src/rules/flake8_pyi/rules/unsupported_method_call_on_all.rs

@@ -47,7 +47,7 @@ pub(crate) fn unsupported_method_call_on_all(checker: &mut Checker, func: &Expr)
     let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() else {
         return;
     };
-    if &**id != "__all__" {
+    if id.as_str() != "__all__" {
         return;
     }
     if !is_unsupported_method(attr.as_str()) {

crates/ruff_linter/src/rules/flake8_pytest_style/rules/assertion.rs

@@ -242,7 +242,7 @@ where
         match expr {
             Expr::Name(ast::ExprName { id, .. }) => {
                 if let Some(current_assert) = self.current_assert {
-                    if &**id == self.exception_name {
+                    if id.as_str() == self.exception_name {
                         self.errors.push(Diagnostic::new(
                             PytestAssertInExcept {
                                 name: id.to_string(),
@@ -411,7 +411,7 @@ fn to_pytest_raises_args<'a>(
 ) -> Option<Cow<'a, str>> {
     let args = match attr {
         "assertRaises" | "failUnlessRaises" => {
-            match (&*arguments.args, &*arguments.keywords) {
+            match (arguments.args.as_slice(), arguments.keywords.as_slice()) {
                 // Ex) `assertRaises(Exception)`
                 ([arg], []) => Cow::Borrowed(checker.locator().slice(arg)),
                 // Ex) `assertRaises(expected_exception=Exception)`
@@ -419,7 +419,7 @@ fn to_pytest_raises_args<'a>(
                     if kwarg
                         .arg
                         .as_ref()
-                        .is_some_and(|id| &**id == "expected_exception") =>
+                        .is_some_and(|id| id.as_str() == "expected_exception") =>
                 {
                     Cow::Borrowed(checker.locator().slice(kwarg.value.range()))
                 }
@@ -427,7 +427,7 @@ fn to_pytest_raises_args<'a>(
             }
         }
         "assertRaisesRegex" | "assertRaisesRegexp" => {
-            match (&*arguments.args, &*arguments.keywords) {
+            match (arguments.args.as_slice(), arguments.keywords.as_slice()) {
                 // Ex) `assertRaisesRegex(Exception, regex)`
                 ([arg1, arg2], []) => Cow::Owned(format!(
                     "{}, match={}",
@@ -452,11 +452,11 @@ fn to_pytest_raises_args<'a>(
                     if kwarg1
                         .arg
                         .as_ref()
-                        .is_some_and(|id| &**id == "expected_exception")
+                        .is_some_and(|id| id.as_str() == "expected_exception")
                         && kwarg2
                             .arg
                             .as_ref()
-                            .is_some_and(|id| &**id == "expected_regex") =>
+                            .is_some_and(|id| id.as_str() == "expected_regex") =>
                 {
                     Cow::Owned(format!(
                         "{}, match={}",
@@ -469,11 +469,11 @@ fn to_pytest_raises_args<'a>(
                     if kwarg1
                         .arg
                         .as_ref()
-                        .is_some_and(|id| &**id == "expected_regex")
+                        .is_some_and(|id| id.as_str() == "expected_regex")
                         && kwarg2
                             .arg
                             .as_ref()
-                            .is_some_and(|id| &**id == "expected_exception") =>
+                            .is_some_and(|id| id.as_str() == "expected_exception") =>
                 {
                     Cow::Owned(format!(
                         "{}, match={}",

crates/ruff_linter/src/rules/flake8_pytest_style/rules/marks.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Decorator, Expr};
+use ruff_python_ast::{self as ast, Arguments, Decorator, Expr};
 
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
@@ -137,10 +137,18 @@ fn check_mark_parentheses(checker: &mut Checker, decorator: &Decorator, marker:
     match &decorator.expression {
         Expr::Call(ast::ExprCall {
             func,
-            arguments,
+            arguments:
+                Arguments {
+                    args,
+                    keywords,
+                    range: _,
+                },
             range: _,
         }) => {
-            if !checker.settings.flake8_pytest_style.mark_parentheses && arguments.is_empty() {
+            if !checker.settings.flake8_pytest_style.mark_parentheses
+                && args.is_empty()
+                && keywords.is_empty()
+            {
                 let fix = Fix::safe_edit(Edit::deletion(func.end(), decorator.end()));
                 pytest_mark_parentheses(checker, decorator, marker, fix, "", "()");
             }
@@ -163,8 +171,11 @@ fn check_useless_usefixtures(checker: &mut Checker, decorator: &Decorator, marke
         // @pytest.mark.usefixtures
         Expr::Attribute(..) => {}
         // @pytest.mark.usefixtures(...)
-        Expr::Call(ast::ExprCall { arguments, .. }) => {
-            if !arguments.is_empty() {
+        Expr::Call(ast::ExprCall {
+            arguments: Arguments { args, keywords, .. },
+            ..
+        }) => {
+            if !args.is_empty() || !keywords.is_empty() {
                 return;
             }
         }

crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -7,7 +7,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_ast::parenthesize::parenthesized_range;
 use ruff_python_ast::AstNode;
-use ruff_python_ast::{self as ast, Decorator, Expr, ExprContext};
+use ruff_python_ast::{self as ast, Arguments, Decorator, Expr, ExprContext};
 use ruff_python_codegen::Generator;
 use ruff_python_trivia::CommentRanges;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
@@ -257,18 +257,15 @@ fn elts_to_csv(elts: &[Expr], generator: Generator) -> Option<String> {
     }
 
     let node = Expr::from(ast::StringLiteral {
-        value: elts
-            .iter()
-            .fold(String::new(), |mut acc, elt| {
-                if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = elt {
-                    if !acc.is_empty() {
-                        acc.push(',');
-                    }
-                    acc.push_str(value.to_str());
+        value: elts.iter().fold(String::new(), |mut acc, elt| {
+            if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = elt {
+                if !acc.is_empty() {
+                    acc.push(',');
                 }
-                acc
-            })
-            .into_boxed_str(),
+                acc.push_str(value.to_str());
+            }
+            acc
+        }),
         ..ast::StringLiteral::default()
     });
     Some(generator.expr(&node))
@@ -330,7 +327,7 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                                 .iter()
                                 .map(|name| {
                                     Expr::from(ast::StringLiteral {
-                                        value: (*name).to_string().into_boxed_str(),
+                                        value: (*name).to_string(),
                                         ..ast::StringLiteral::default()
                                     })
                                 })
@@ -363,7 +360,7 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                                 .iter()
                                 .map(|name| {
                                     Expr::from(ast::StringLiteral {
-                                        value: (*name).to_string().into_boxed_str(),
+                                        value: (*name).to_string(),
                                         ..ast::StringLiteral::default()
                                     })
                                 })
@@ -632,19 +629,23 @@ fn handle_value_rows(
 pub(crate) fn parametrize(checker: &mut Checker, decorators: &[Decorator]) {
     for decorator in decorators {
         if is_pytest_parametrize(decorator, checker.semantic()) {
-            if let Expr::Call(ast::ExprCall { arguments, .. }) = &decorator.expression {
+            if let Expr::Call(ast::ExprCall {
+                arguments: Arguments { args, .. },
+                ..
+            }) = &decorator.expression
+            {
                 if checker.enabled(Rule::PytestParametrizeNamesWrongType) {
-                    if let [names, ..] = &*arguments.args {
+                    if let [names, ..] = args.as_slice() {
                         check_names(checker, decorator, names);
                     }
                 }
                 if checker.enabled(Rule::PytestParametrizeValuesWrongType) {
-                    if let [names, values, ..] = &*arguments.args {
+                    if let [names, values, ..] = args.as_slice() {
                         check_values(checker, names, values);
                     }
                 }
                 if checker.enabled(Rule::PytestDuplicateParametrizeTestCases) {
-                    if let [_, values, ..] = &*arguments.args {
+                    if let [_, values, ..] = args.as_slice() {
                         check_duplicates(checker, values);
                     }
                 }