[ruff] Stabilize checking in presence of slices for collection-literal-concatenation (RUF005) (#18500)

Author: dylwil3

crates/ruff_linter/src/preview.rs

@@ -104,13 +104,6 @@ pub(crate) const fn is_unicode_to_unicode_confusables_enabled(settings: &LinterS
     settings.preview.is_enabled()
 }
 
-// https://github.com/astral-sh/ruff/pull/17078
-pub(crate) const fn is_support_slices_in_literal_concatenation_enabled(
-    settings: &LinterSettings,
-) -> bool {
-    settings.preview.is_enabled()
-}
-
 // https://github.com/astral-sh/ruff/pull/11370
 pub(crate) const fn is_undefined_export_in_dunder_init_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()

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

@@ -24,6 +24,7 @@ mod tests {
     use crate::{assert_messages, settings};
 
     #[test_case(Rule::CollectionLiteralConcatenation, Path::new("RUF005.py"))]
+    #[test_case(Rule::CollectionLiteralConcatenation, Path::new("RUF005_slices.py"))]
     #[test_case(Rule::AsyncioDanglingTask, Path::new("RUF006.py"))]
     #[test_case(Rule::ZipInsteadOfPairwise, Path::new("RUF007.py"))]
     #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008.py"))]
@@ -483,7 +484,6 @@ mod tests {
     #[test_case(Rule::ClassWithMixedTypeVars, Path::new("RUF053.py"))]
     #[test_case(Rule::IndentedFormFeed, Path::new("RUF054.py"))]
     #[test_case(Rule::ImplicitClassVarInDataclass, Path::new("RUF045.py"))]
-    #[test_case(Rule::CollectionLiteralConcatenation, Path::new("RUF005_slices.py"))]
     fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

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

@@ -4,7 +4,6 @@ use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
 use crate::fix::snippet::SourceCodeSnippet;
-use crate::preview::is_support_slices_in_literal_concatenation_enabled;
 use crate::{Edit, Fix, FixAvailability, Violation};
 
 /// ## What it does
@@ -96,7 +95,7 @@ enum Type {
 }
 
 /// Recursively merge all the tuples and lists in the expression.
-fn concatenate_expressions(expr: &Expr, should_support_slices: bool) -> Option<(Expr, Type)> {
+fn concatenate_expressions(expr: &Expr) -> Option<(Expr, Type)> {
     let Expr::BinOp(ast::ExprBinOp {
         left,
         op: Operator::Add,
@@ -108,22 +107,18 @@ fn concatenate_expressions(expr: &Expr, should_support_slices: bool) -> Option<(
     };
 
     let new_left = match left.as_ref() {
-        Expr::BinOp(ast::ExprBinOp { .. }) => {
-            match concatenate_expressions(left, should_support_slices) {
-                Some((new_left, _)) => new_left,
-                None => *left.clone(),
-            }
-        }
+        Expr::BinOp(ast::ExprBinOp { .. }) => match concatenate_expressions(left) {
+            Some((new_left, _)) => new_left,
+            None => *left.clone(),
+        },
         _ => *left.clone(),
     };
 
     let new_right = match right.as_ref() {
-        Expr::BinOp(ast::ExprBinOp { .. }) => {
-            match concatenate_expressions(right, should_support_slices) {
-                Some((new_right, _)) => new_right,
-                None => *right.clone(),
-            }
-        }
+        Expr::BinOp(ast::ExprBinOp { .. }) => match concatenate_expressions(right) {
+            Some((new_right, _)) => new_right,
+            None => *right.clone(),
+        },
         _ => *right.clone(),
     };
 
@@ -151,9 +146,7 @@ fn concatenate_expressions(expr: &Expr, should_support_slices: bool) -> Option<(
             make_splat_elts(splat_element, other_elements, splat_at_left)
         }
         // Subscripts are also considered safe-ish to splat if the indexer is a slice.
-        Expr::Subscript(ast::ExprSubscript { slice, .. })
-            if should_support_slices && matches!(&**slice, Expr::Slice(_)) =>
-        {
+        Expr::Subscript(ast::ExprSubscript { slice, .. }) if matches!(&**slice, Expr::Slice(_)) => {
             make_splat_elts(splat_element, other_elements, splat_at_left)
         }
         // If the splat element is itself a list/tuple, insert them in the other list/tuple.
@@ -198,10 +191,7 @@ pub(crate) fn collection_literal_concatenation(checker: &Checker, expr: &Expr) {
         return;
     }
 
-    let should_support_slices =
-        is_support_slices_in_literal_concatenation_enabled(checker.settings);
-
-    let Some((new_expr, type_)) = concatenate_expressions(expr, should_support_slices) else {
+    let Some((new_expr, type_)) = concatenate_expressions(expr) else {
         return;
     };