[ruff] Implement incorrectly-parenthesized-tuple-in-subscript (RUF031)

crates/ruff/tests/snapshots/show_settings__display_default_settings.snap

@@ -370,6 +370,7 @@ linter.pylint.max_statements = 50
 linter.pylint.max_public_methods = 20
 linter.pylint.max_locals = 15
 linter.pyupgrade.keep_runtime_typing = false
+linter.ruff.parenthesize_tuple_in_subscript = false
 
 # Formatter Settings
 formatter.exclude = []

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

@@ -0,0 +1,28 @@
+d = {(1,2):"a",(3,4):"b",(5,6,7):"c",(8,):"d"}
+d[(1,2)]
+d[(
+    1,
+    2
+)]
+d[
+    1,
+    2
+]
+d[(2,4)]
+d[(5,6,7)]
+d[(8,)]
+d[tuple(1,2)]
+d[tuple(8)]
+d[1,2]
+d[3,4]
+d[5,6,7]
+e = {((1,2),(3,4)):"a"}
+e[((1,2),(3,4))]
+e[(1,2),(3,4)]
+
+token_features[
+    (window_position, feature_name)
+] = self._extract_raw_features_from_token
+
+d[1,]
+d[(1,)]

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

@@ -0,0 +1,27 @@
+d = {(1,2):"a",(3,4):"b",(5,6,7):"c",(8,):"d"}
+d[(1,2)]
+d[(
+    1,
+    2
+)]
+d[
+    1,
+    2
+]
+d[(2,4)]
+d[(5,6,7)]
+d[(8,)]
+d[tuple(1,2)]
+d[tuple(8)]
+d[1,2]
+d[3,4]
+d[5,6,7]
+e = {((1,2),(3,4)):"a"}
+e[((1,2),(3,4))]
+e[(1,2),(3,4)]
+
+token_features[
+    (window_position, feature_name)
+] = self._extract_raw_features_from_token
+d[1,]
+d[(1,)]

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

@@ -146,6 +146,10 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 refurb::rules::fstring_number_format(checker, subscript);
             }
 
+            if checker.enabled(Rule::IncorrectlyParenthesizedTupleInSubscript) {
+                ruff::rules::subscript_with_parenthesized_tuple(checker, subscript);
+            }
+
             pandas_vet::rules::subscript(checker, value, expr);
         }
         Expr::Tuple(ast::ExprTuple {

crates/ruff_linter/src/codes.rs

@@ -957,6 +957,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "028") => (RuleGroup::Preview, rules::ruff::rules::InvalidFormatterSuppressionComment),
         (Ruff, "029") => (RuleGroup::Preview, rules::ruff::rules::UnusedAsync),
         (Ruff, "030") => (RuleGroup::Preview, rules::ruff::rules::AssertWithPrintMessage),
+        (Ruff, "031") => (RuleGroup::Preview, rules::ruff::rules::IncorrectlyParenthesizedTupleInSubscript),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "101") => (RuleGroup::Preview, rules::ruff::rules::RedirectedNOQA),
 

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

@@ -1,6 +1,7 @@
 //! Ruff-specific rules.
 
 pub(crate) mod rules;
+pub mod settings;
 pub(crate) mod typing;
 
 #[cfg(test)]
@@ -19,6 +20,7 @@ mod tests {
     use crate::settings::types::{
         CompiledPerFileIgnoreList, PerFileIgnore, PreviewMode, PythonVersion,
     };
+    use crate::settings::LinterSettings;
     use crate::test::{test_path, test_resource_path};
     use crate::{assert_messages, settings};
 
@@ -55,6 +57,7 @@ mod tests {
     #[test_case(Rule::InvalidFormatterSuppressionComment, Path::new("RUF028.py"))]
     #[test_case(Rule::UnusedAsync, Path::new("RUF029.py"))]
     #[test_case(Rule::AssertWithPrintMessage, Path::new("RUF030.py"))]
+    #[test_case(Rule::IncorrectlyParenthesizedTupleInSubscript, Path::new("RUF031.py"))]
     #[test_case(Rule::RedirectedNOQA, Path::new("RUF101.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
@@ -66,6 +69,21 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn prefer_parentheses_getitem_tuple() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("ruff/RUF031_prefer_parens.py"),
+            &LinterSettings {
+                ruff: super::settings::Settings {
+                    parenthesize_tuple_in_subscript: true,
+                },
+                ..LinterSettings::for_rule(Rule::IncorrectlyParenthesizedTupleInSubscript)
+            },
+        )?;
+        assert_messages!(diagnostics);
+        Ok(())
+    }
+
     #[test_case(Path::new("RUF013_0.py"))]
     #[test_case(Path::new("RUF013_1.py"))]
     fn implicit_optional_py39(path: &Path) -> Result<()> {

crates/ruff_linter/src/rules/ruff/rules/incorrectly_parenthesized_tuple_in_getitem.rs

@@ -0,0 +1,82 @@
+// In case we want to change the boolean setting for
+// this rule to an enum, this will make the code change
+// just a little simpler.
+#![allow(clippy::match_bool)]
+
+use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::ExprSubscript;
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for use or omission of parentheses around tuples in subscripts,
+/// depending on the setting [`lint.ruff.parenthesize-tuple-in-subscript`]. By default, the use of parentheses
+/// is considered a violation.
+///
+/// ## Why is this bad?
+/// It is good to be consistent and, depending on the codebase, one or the other
+/// convention may be preferred.
+///
+/// ## Example
+///
+/// ```python
+/// directions = {(0, 1): "North", (-1, 0): "East", (0, -1): "South", (1, 0): "West"}
+/// directions[(0, 1)]
+/// ```
+///
+/// Use instead (with default setting):
+///
+/// ```python
+/// directions = {(0, 1): "North", (-1, 0): "East", (0, -1): "South", (1, 0): "West"}
+/// directions[0, 1]
+/// ```
+
+#[violation]
+pub struct IncorrectlyParenthesizedTupleInSubscript {
+    prefer_parentheses: bool,
+}
+
+impl AlwaysFixableViolation for IncorrectlyParenthesizedTupleInSubscript {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        match self.prefer_parentheses {
+            true => format!("Use parentheses for tuples in subscripts."),
+            false => format!("Avoid parentheses for tuples in scubscripts."),
+        }
+    }
+
+    fn fix_title(&self) -> String {
+        match self.prefer_parentheses {
+            true => "Add parentheses around tuple in subscript.".to_string(),
+            false => "Remove parentheses from tuple in subscript.".to_string(),
+        }
+    }
+}
+
+/// RUF031
+pub(crate) fn subscript_with_parenthesized_tuple(checker: &mut Checker, subscript: &ExprSubscript) {
+    let prefer_parentheses = checker.settings.ruff.parenthesize_tuple_in_subscript;
+    let Some(tuple_index) = subscript.slice.as_tuple_expr() else {
+        return;
+    };
+    if tuple_index.parenthesized != prefer_parentheses {
+        let locator = checker.locator();
+        let source_range = subscript.slice.range();
+        let new_source = match prefer_parentheses {
+            true => {
+                format!("({})", locator.slice(source_range))
+            }
+            false => locator.slice(source_range)[1..source_range.len().to_usize() - 1].to_string(),
+        };
+        let edit = Edit::range_replacement(new_source, source_range);
+        checker.diagnostics.push(
+            Diagnostic::new(
+                IncorrectlyParenthesizedTupleInSubscript { prefer_parentheses },
+                source_range,
+            )
+            .with_fix(Fix::safe_edit(edit)),
+        );
+    }
+}

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

@@ -7,6 +7,7 @@ pub(crate) use default_factory_kwarg::*;
 pub(crate) use explicit_f_string_type_conversion::*;
 pub(crate) use function_call_in_dataclass_default::*;
 pub(crate) use implicit_optional::*;
+pub(crate) use incorrectly_parenthesized_tuple_in_getitem::*;
 pub(crate) use invalid_formatter_suppression_comment::*;
 pub(crate) use invalid_index_type::*;
 pub(crate) use invalid_pyproject_toml::*;
@@ -41,6 +42,7 @@ mod explicit_f_string_type_conversion;
 mod function_call_in_dataclass_default;
 mod helpers;
 mod implicit_optional;
+mod incorrectly_parenthesized_tuple_in_getitem;
 mod invalid_formatter_suppression_comment;
 mod invalid_index_type;
 mod invalid_pyproject_toml;

crates/ruff_linter/src/rules/ruff/settings.rs

@@ -0,0 +1,23 @@
+//! Settings for the `ruff` plugin.
+
+use crate::display_settings;
+use ruff_macros::CacheKey;
+use std::fmt;
+
+#[derive(Debug, Clone, CacheKey, Default)]
+pub struct Settings {
+    pub parenthesize_tuple_in_subscript: bool,
+}
+
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.ruff",
+            fields = [
+                self.parenthesize_tuple_in_subscript
+            ]
+        }
+        Ok(())
+    }
+}