Gate RUF005 slice support as preview feature

Author: akx

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

@@ -47,10 +47,6 @@ def yay(self):
 astonishment = ("we all feel",) + Fun.words
 
 chain = ["a", "b", "c"] + eggs + list(("yes", "no", "pants") + zoob)
-slicing1 = foo[:1] + [7, 8, 9]
-slicing2 = [7, 8, 9] + bar[1:]
-slicing3 = foo[:1] + [7, 8, 9] + bar[1:]
-indexing = foo[0] + [7, 8, 9] + bar[1]  # Not changed; looks a little suspect for concatenation.
 
 baz = () + zoob
 

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

@@ -0,0 +1,6 @@
+foo = [4, 5, 6]
+bar = [1, 2, 3] + foo
+slicing1 = foo[:1] + [7, 8, 9]
+slicing2 = [7, 8, 9] + bar[1:]
+slicing3 = foo[:1] + [7, 8, 9] + bar[1:]
+indexing = foo[0] + [7, 8, 9] + bar[1]  # Not changed; looks a little suspect for concatenation.

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

@@ -109,6 +109,19 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn preview_ruf005_slices() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("ruff/RUF005_slices.py"),
+            &LinterSettings {
+                preview: PreviewMode::Enabled,
+                ..LinterSettings::for_rules(vec![Rule::CollectionLiteralConcatenation])
+            },
+        )?;
+        assert_messages!(diagnostics);
+        Ok(())
+    }
+
     #[test]
     fn prefer_parentheses_getitem_tuple() -> Result<()> {
         let diagnostics = test_path(

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

@@ -89,7 +89,7 @@ enum Type {
 }
 
 /// Recursively merge all the tuples and lists in the expression.
-fn concatenate_expressions(expr: &Expr) -> Option<(Expr, Type)> {
+fn concatenate_expressions(expr: &Expr, should_support_slices: bool) -> Option<(Expr, Type)> {
     let Expr::BinOp(ast::ExprBinOp {
         left,
         op: Operator::Add,
@@ -101,18 +101,22 @@ fn concatenate_expressions(expr: &Expr) -> Option<(Expr, Type)> {
     };
 
     let new_left = match left.as_ref() {
-        Expr::BinOp(ast::ExprBinOp { .. }) => match concatenate_expressions(left) {
-            Some((new_left, _)) => new_left,
-            None => *left.clone(),
-        },
+        Expr::BinOp(ast::ExprBinOp { .. }) => {
+            match concatenate_expressions(left, should_support_slices) {
+                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) {
-            Some((new_right, _)) => new_right,
-            None => *right.clone(),
-        },
+        Expr::BinOp(ast::ExprBinOp { .. }) => {
+            match concatenate_expressions(right, should_support_slices) {
+                Some((new_right, _)) => new_right,
+                None => *right.clone(),
+            }
+        }
         _ => *right.clone(),
     };
 
@@ -140,7 +144,9 @@ fn concatenate_expressions(expr: &Expr) -> Option<(Expr, Type)> {
             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 matches!(&**slice, Expr::Slice(_)) => {
+        Expr::Subscript(ast::ExprSubscript { slice, .. })
+            if should_support_slices && 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.
@@ -185,7 +191,9 @@ pub(crate) fn collection_literal_concatenation(checker: &Checker, expr: &Expr) {
         return;
     }
 
-    let Some((new_expr, type_)) = concatenate_expressions(expr) else {
+    let should_support_slices = checker.settings.preview.is_enabled();
+
+    let Some((new_expr, type_)) = concatenate_expressions(expr, should_support_slices) else {
         return;
     };