[flake8-simplify] Correct behavior for str.split/rsplit with maxsplit=0 (SIM905) (astral-sh#18075)

Fixes astral-sh#18069

<!--
Thank you for contributing to Ruff/ty! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title? (Please prefix
with `[ty]` for ty pull
  requests.)
- Does this pull request include references to any relevant issues?
-->

## Summary

This PR addresses a bug in the `flake8-simplify` rule `SIM905`
(split-static-string) where `str.split(maxsplit=0)` and
`str.rsplit(maxsplit=0)` produced incorrect results for empty strings or
strings starting/ending with whitespace. The fix ensures that the
linting rule's suggested replacements now align with Python's native
behavior for these specific `maxsplit=0` scenarios.

## Test Plan

1. Added new test cases to the existing
`crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM905.py`
fixture to cover the scenarios described in issue astral-sh#18069.
2.  Ran `cargo test -p ruff_linter`.
3. Verified and accepted the updated snapshots for `SIM905.py` using
`cargo insta review`. The new snapshots confirm the corrected behavior
for `maxsplit=0`.

Author: danparizher

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM905.py

@@ -110,3 +110,23 @@
 # https://github.com/astral-sh/ruff/issues/18042
 print("a,b".rsplit(","))
 print("a,b,c".rsplit(",", 1))
+
+# https://github.com/astral-sh/ruff/issues/18069
+
+print("".split(maxsplit=0))
+print("".split(sep=None, maxsplit=0))
+print(" ".split(maxsplit=0))
+print(" ".split(sep=None, maxsplit=0))
+print(" x ".split(maxsplit=0))
+print(" x ".split(sep=None, maxsplit=0))
+print("  x  ".split(maxsplit=0))
+print("  x  ".split(sep=None, maxsplit=0))
+print("".rsplit(maxsplit=0))
+print("".rsplit(sep=None, maxsplit=0))
+print(" ".rsplit(maxsplit=0))
+print(" ".rsplit(sep=None, maxsplit=0))
+print(" x ".rsplit(maxsplit=0))
+print(" x ".rsplit(maxsplit=0))
+print(" x ".rsplit(sep=None, maxsplit=0))
+print("  x  ".rsplit(maxsplit=0))
+print("  x  ".rsplit(sep=None, maxsplit=0))

crates/ruff_linter/src/rules/flake8_simplify/rules/split_static_string.rs

@@ -83,7 +83,7 @@ pub(crate) fn split_static_string(
     let sep_arg = arguments.find_argument_value("sep", 0);
     let split_replacement = if let Some(sep) = sep_arg {
         match sep {
-            Expr::NoneLiteral(_) => split_default(str_value, maxsplit_value),
+            Expr::NoneLiteral(_) => split_default(str_value, maxsplit_value, direction),
             Expr::StringLiteral(sep_value) => {
                 let sep_value_str = sep_value.value.to_str();
                 Some(split_sep(
@@ -99,7 +99,7 @@ pub(crate) fn split_static_string(
             }
         }
     } else {
-        split_default(str_value, maxsplit_value)
+        split_default(str_value, maxsplit_value, direction)
     };
 
     let mut diagnostic = Diagnostic::new(SplitStaticString, call.range());
@@ -144,14 +144,19 @@ fn construct_replacement(elts: &[&str], flags: StringLiteralFlags) -> Expr {
     })
 }
 
-fn split_default(str_value: &StringLiteralValue, max_split: i32) -> Option<Expr> {
+fn split_default(
+    str_value: &StringLiteralValue,
+    max_split: i32,
+    direction: Direction,
+) -> Option<Expr> {
     // From the Python documentation:
     // > If sep is not specified or is None, a different splitting algorithm is applied: runs of
     // > consecutive whitespace are regarded as a single separator, and the result will contain
     // > no empty strings at the start or end if the string has leading or trailing whitespace.
     // > Consequently, splitting an empty string or a string consisting of just whitespace with
     // > a None separator returns [].
     // https://docs.python.org/3/library/stdtypes.html#str.split
+    let string_val = str_value.to_str();
     match max_split.cmp(&0) {
         Ordering::Greater => {
             // Autofix for `maxsplit` without separator not yet implemented, as
@@ -160,14 +165,30 @@ fn split_default(str_value: &StringLiteralValue, max_split: i32) -> Option<Expr>
             None
         }
         Ordering::Equal => {
-            let list_items: Vec<&str> = vec![str_value.to_str()];
+            // Behavior for maxsplit = 0 when sep is None:
+            // - If the string is empty or all whitespace, result is [].
+            // - Otherwise:
+            //   - " x ".split(maxsplit=0)  -> ['x ']
+            //   - " x ".rsplit(maxsplit=0) -> [' x']
+            //   - "".split(maxsplit=0) -> []
+            //   - " ".split(maxsplit=0) -> []
+            let processed_str = if direction == Direction::Left {
+                string_val.trim_start()
+            } else {
+                string_val.trim_end()
+            };
+            let list_items: &[_] = if processed_str.is_empty() {
+                &[]
+            } else {
+                &[processed_str]
+            };
             Some(construct_replacement(
-                &list_items,
+                list_items,
                 str_value.first_literal_flags(),
             ))
         }
         Ordering::Less => {
-            let list_items: Vec<&str> = str_value.to_str().split_whitespace().collect();
+            let list_items: Vec<&str> = string_val.split_whitespace().collect();
             Some(construct_replacement(
                 &list_items,
                 str_value.first_literal_flags(),