[flake8-bugbear] Include certain guaranteed-mutable expressions: tuples, generators, and assignment expressions (B006) (#20024)

## Summary
Resolves #20004

The implementation now supports guaranteed-mutable expressions in the
following cases:
- Tuple literals with mutable elements (supporting deep nesting)
- Generator expressions
- Named expressions (walrus operator) containing mutable components

Preserves original formatting for assignment value:

```python
# Test case
def f5(x=([1, ])):
    print(x)
```
```python
# Fix before
def f5(x=(None)):
    if x is None:
        x = [1]
    print(x)
```
```python
# Fix after 
def f5(x=None):
    if x is None:
        x = ([1, ])
    print(x)
```
The expansion of detected expressions and the new fixes gated behind
previews.

## Test Plan
- Added B006_9.py with a bunch of test cases
- Generated snapshots

---------

Co-authored-by: Igor Drokin <drokinii1017@gmail.com>
Co-authored-by: dylwil3 <dylwil3@gmail.com>

Author: 3 people

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B006_9.py

@@ -0,0 +1,26 @@
+def f1(x=([],)):
+    print(x)
+
+
+def f2(x=(x for x in "x")):
+    print(x)
+
+
+def f3(x=((x for x in "x"),)):
+    print(x)
+
+
+def f4(x=(z := [1, ])):
+    print(x)
+
+
+def f5(x=([1, ])):
+    print(x)
+
+
+def w1(x=(1,)):
+    print(x)
+
+
+def w2(x=(z := 3)):
+    print(x)

crates/ruff_linter/src/preview.rs

@@ -245,3 +245,17 @@ pub(crate) const fn is_a003_class_scope_shadowing_expansion_enabled(
 pub(crate) const fn is_refined_submodule_import_match_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+
+// github.com/astral-sh/ruff/issues/20004
+pub(crate) const fn is_b006_check_guaranteed_mutable_expr_enabled(
+    settings: &LinterSettings,
+) -> bool {
+    settings.preview.is_enabled()
+}
+
+// github.com/astral-sh/ruff/issues/20004
+pub(crate) const fn is_b006_unsafe_fix_preserve_assignment_expr_enabled(
+    settings: &LinterSettings,
+) -> bool {
+    settings.preview.is_enabled()
+}

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

@@ -47,6 +47,7 @@ mod tests {
     #[test_case(Rule::MutableArgumentDefault, Path::new("B006_6.py"))]
     #[test_case(Rule::MutableArgumentDefault, Path::new("B006_7.py"))]
     #[test_case(Rule::MutableArgumentDefault, Path::new("B006_8.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_9.py"))]
     #[test_case(Rule::MutableArgumentDefault, Path::new("B006_B008.py"))]
     #[test_case(Rule::MutableArgumentDefault, Path::new("B006_1.pyi"))]
     #[test_case(Rule::NoExplicitStacklevel, Path::new("B028.py"))]
@@ -83,6 +84,17 @@ mod tests {
     }
 
     #[test_case(Rule::MapWithoutExplicitStrict, Path::new("B912.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_1.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_2.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_3.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_4.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_5.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_6.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_7.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_8.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_9.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_B008.py"))]
+    #[test_case(Rule::MutableArgumentDefault, Path::new("B006_1.pyi"))]
     fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

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

@@ -3,18 +3,20 @@ use std::fmt::Write;
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::helpers::is_docstring_stmt;
 use ruff_python_ast::name::QualifiedName;
-use ruff_python_ast::{self as ast, Expr, Parameter};
-use ruff_python_codegen::{Generator, Stylist};
-use ruff_python_index::Indexer;
+use ruff_python_ast::parenthesize::parenthesized_range;
+use ruff_python_ast::{self as ast, Expr, ParameterWithDefault};
 use ruff_python_semantic::SemanticModel;
 use ruff_python_semantic::analyze::function_type::is_stub;
 use ruff_python_semantic::analyze::typing::{is_immutable_annotation, is_mutable_expr};
 use ruff_python_trivia::{indentation_at_offset, textwrap};
 use ruff_source_file::LineRanges;
 use ruff_text_size::Ranged;
 
-use crate::Locator;
 use crate::checkers::ast::Checker;
+use crate::preview::{
+    is_b006_check_guaranteed_mutable_expr_enabled,
+    is_b006_unsafe_fix_preserve_assignment_expr_enabled,
+};
 use crate::{Edit, Fix, FixAvailability, Violation};
 
 /// ## What it does
@@ -111,44 +113,50 @@ pub(crate) fn mutable_argument_default(checker: &Checker, function_def: &ast::St
             .iter()
             .map(|target| QualifiedName::from_dotted_name(target))
             .collect();
-
-        if is_mutable_expr(default, checker.semantic())
+        let is_mut_expr = if is_b006_check_guaranteed_mutable_expr_enabled(checker.settings()) {
+            is_guaranteed_mutable_expr(default, checker.semantic())
+        } else {
+            is_mutable_expr(default, checker.semantic())
+        };
+        if is_mut_expr
             && !parameter.annotation().is_some_and(|expr| {
                 is_immutable_annotation(expr, checker.semantic(), extend_immutable_calls.as_slice())
             })
         {
             let mut diagnostic = checker.report_diagnostic(MutableArgumentDefault, default.range());
 
             // If the function body is on the same line as the function def, do not fix
-            if let Some(fix) = move_initialization(
-                function_def,
-                &parameter.parameter,
-                default,
-                checker.semantic(),
-                checker.locator(),
-                checker.stylist(),
-                checker.indexer(),
-                checker.generator(),
-            ) {
+            if let Some(fix) = move_initialization(function_def, parameter, default, checker) {
                 diagnostic.set_fix(fix);
             }
         }
     }
 }
 
+/// Returns `true` if the expression is guaranteed to create a mutable object.
+fn is_guaranteed_mutable_expr(expr: &Expr, semantic: &SemanticModel) -> bool {
+    match expr {
+        Expr::Generator(_) => true,
+        Expr::Tuple(ast::ExprTuple { elts, .. }) => {
+            elts.iter().any(|e| is_guaranteed_mutable_expr(e, semantic))
+        }
+        Expr::Named(ast::ExprNamed { value, .. }) => is_guaranteed_mutable_expr(value, semantic),
+        _ => is_mutable_expr(expr, semantic),
+    }
+}
+
 /// Generate a [`Fix`] to move a mutable argument default initialization
 /// into the function body.
-#[expect(clippy::too_many_arguments)]
 fn move_initialization(
     function_def: &ast::StmtFunctionDef,
-    parameter: &Parameter,
+    parameter: &ParameterWithDefault,
     default: &Expr,
-    semantic: &SemanticModel,
-    locator: &Locator,
-    stylist: &Stylist,
-    indexer: &Indexer,
-    generator: Generator,
+    checker: &Checker,
 ) -> Option<Fix> {
+    let indexer = checker.indexer();
+    let locator = checker.locator();
+    let stylist = checker.stylist();
+
     let mut body = function_def.body.iter().peekable();
 
     // Avoid attempting to fix single-line functions.
@@ -157,25 +165,58 @@ fn move_initialization(
         return None;
     }
 
+    let range = match parenthesized_range(
+        default.into(),
+        parameter.into(),
+        checker.comment_ranges(),
+        checker.source(),
+    ) {
+        Some(range) => range,
+        None => default.range(),
+    };
     // Set the default argument value to `None`.
-    let default_edit = Edit::range_replacement("None".to_string(), default.range());
+    let default_edit = Edit::range_replacement("None".to_string(), range);
 
     // If the function is a stub, this is the only necessary edit.
-    if is_stub(function_def, semantic) {
+    if is_stub(function_def, checker.semantic()) {
         return Some(Fix::unsafe_edit(default_edit));
     }
 
     // Add an `if`, to set the argument to its original value if still `None`.
     let mut content = String::new();
-    let _ = write!(&mut content, "if {} is None:", parameter.name());
+    let _ = write!(&mut content, "if {} is None:", parameter.parameter.name());
     content.push_str(stylist.line_ending().as_str());
     content.push_str(stylist.indentation());
-    let _ = write!(
-        &mut content,
-        "{} = {}",
-        parameter.name(),
-        generator.expr(default)
-    );
+    if is_b006_unsafe_fix_preserve_assignment_expr_enabled(checker.settings()) {
+        let annotation = if let Some(ann) = parameter.annotation() {
+            format!(": {}", locator.slice(ann))
+        } else {
+            String::new()
+        };
+        let _ = write!(
+            &mut content,
+            "{}{} = {}",
+            parameter.parameter.name(),
+            annotation,
+            locator.slice(
+                parenthesized_range(
+                    default.into(),
+                    parameter.into(),
+                    checker.comment_ranges(),
+                    checker.source()
+                )
+                .unwrap_or(default.range())
+            )
+        );
+    } else {
+        let _ = write!(
+            &mut content,
+            "{} = {}",
+            parameter.name(),
+            checker.generator().expr(default)
+        );
+    }
+
     content.push_str(stylist.line_ending().as_str());
 
     // Determine the indentation depth of the function body.

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__B006_B006_9.py.snap

@@ -0,0 +1,22 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B006 [*] Do not use mutable data structures for argument defaults
+  --> B006_9.py:17:11
+   |
+17 | def f5(x=([1, ])):
+   |           ^^^^^
+18 |     print(x)
+   |
+help: Replace with `None`; initialize within function
+14 |     print(x)
+15 | 
+16 | 
+   - def f5(x=([1, ])):
+17 + def f5(x=None):
+18 +     if x is None:
+19 +         x = [1]
+20 |     print(x)
+21 | 
+22 | 
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_1.py.snap

@@ -0,0 +1,21 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B006 [*] Do not use mutable data structures for argument defaults
+ --> B006_1.py:3:22
+  |
+1 | # Docstring followed by a newline
+2 |
+3 | def foobar(foor, bar={}):    
+  |                      ^^
+4 |     """
+5 |     """
+  |
+help: Replace with `None`; initialize within function
+1 | # Docstring followed by a newline
+2 | 
+  - def foobar(foor, bar={}):    
+3 + def foobar(foor, bar=None):    
+4 |     """
+5 |     """
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_1.pyi.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_2.py.snap

@@ -0,0 +1,22 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B006 [*] Do not use mutable data structures for argument defaults
+ --> B006_2.py:4:22
+  |
+2 | # Regression test for https://github.com/astral-sh/ruff/issues/7155
+3 |
+4 | def foobar(foor, bar={}):    
+  |                      ^^
+5 |     """
+6 |     """                    
+  |
+help: Replace with `None`; initialize within function
+1 | # Docstring followed by whitespace with no newline
+2 | # Regression test for https://github.com/astral-sh/ruff/issues/7155
+3 | 
+  - def foobar(foor, bar={}):    
+4 + def foobar(foor, bar=None):    
+5 |     """
+6 |     """                    
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_3.py.snap

@@ -0,0 +1,20 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B006 [*] Do not use mutable data structures for argument defaults
+ --> B006_3.py:4:22
+  |
+4 | def foobar(foor, bar={}):    
+  |                      ^^
+5 |     """
+6 |     """
+  |
+help: Replace with `None`; initialize within function
+1 | # Docstring with no newline
+2 | 
+3 | 
+  - def foobar(foor, bar={}):    
+4 + def foobar(foor, bar=None):    
+5 |     """
+6 |     """
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_4.py.snap

@@ -0,0 +1,22 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B006 [*] Do not use mutable data structures for argument defaults
+ --> B006_4.py:7:26
+  |
+6 | class FormFeedIndent:
+7 |    def __init__(self, a=[]):
+  |                         ^^
+8 |         print(a)
+  |
+help: Replace with `None`; initialize within function
+4  | 
+5  | 
+6  | class FormFeedIndent:
+   -    def __init__(self, a=[]):
+7  +    def __init__(self, a=None):
+8  +         if a is None:
+9  +          a = []
+10 |         print(a)
+11 | 
+note: This is an unsafe fix and may change runtime behavior