Fix string_processing error with unassigned long string literal with trailing comma (psf#4929)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: cobalt <61329810+cobaltt7@users.noreply.github.com>

Author: 3 people

CHANGES.md

@@ -17,6 +17,8 @@
 
 <!-- Changes that affect Black's preview style -->
 
+- Fix `string_processing` crashing on unassigned long string literals with trailing
+  commas (one-item tuples) (#4929)
 - Simplify implementation of the power operator "hugging" logic (#4918)
 
 - Always wrap `in` clauses of comprehensions if they have delimiters (#4881)

src/black/trans.py

@@ -1431,6 +1431,20 @@ def do_splitter_match(self, line: Line) -> TMatchResult:
         if self._prefer_paren_wrap_match(LL) is not None:
             return TErr("Line needs to be wrapped in parens first.")
 
+        # If the line is just STRING + COMMA (a one-item tuple) and not inside
+        # brackets, we need to defer to StringParenWrapper to wrap it first.
+        # Otherwise, splitting the string would create multiple expressions where
+        # only the last has the comma, breaking AST equivalence. See issue #4912.
+        if (
+            not line.inside_brackets
+            and len(LL) == 2
+            and LL[0].type == token.STRING
+            and LL[1].type == token.COMMA
+        ):
+            return TErr(
+                "Line with trailing comma tuple needs to be wrapped in parens first."
+            )
+
         is_valid_index = is_valid_index_factory(LL)
 
         idx = 0
@@ -1964,9 +1978,14 @@ def do_splitter_match(self, line: Line) -> TMatchResult:
             or self._assert_match(LL)
             or self._assign_match(LL)
             or self._dict_or_lambda_match(LL)
-            or self._prefer_paren_wrap_match(LL)
         )
 
+        if string_idx is None:
+            string_idx = self._trailing_comma_tuple_match(line)
+
+        if string_idx is None:
+            string_idx = self._prefer_paren_wrap_match(LL)
+
         if string_idx is not None:
             string_value = line.leaves[string_idx].value
             # If the string has neither spaces nor East Asian stops...
@@ -2161,6 +2180,32 @@ def _dict_or_lambda_match(LL: list[Leaf]) -> int | None:
 
         return None
 
+    @staticmethod
+    def _trailing_comma_tuple_match(line: Line) -> int | None:
+        """
+        Returns:
+            string_idx such that @line.leaves[string_idx] is equal to our target
+            (i.e. matched) string, if the line is a bare trailing comma tuple
+            (STRING + COMMA) not inside brackets.
+                OR
+            None, otherwise.
+
+        This handles the case from issue #4912 where a long string with a
+        trailing comma (making it a one-item tuple) needs to be wrapped in
+        parentheses before splitting to preserve AST equivalence.
+        """
+        LL = line.leaves
+        # Match: STRING followed by COMMA, not inside brackets
+        if (
+            not line.inside_brackets
+            and len(LL) == 2
+            and LL[0].type == token.STRING
+            and LL[1].type == token.COMMA
+        ):
+            return 0
+
+        return None
+
     def do_transform(
         self, line: Line, string_indices: list[int]
     ) -> Iterator[TResult[Line]]:

tests/data/cases/preview_long_strings.py

@@ -39,6 +39,9 @@
 
 T2 = ("This is a really long string that can't be expected to fit in one line and is the only child of a tuple literal.",)
 
+# Test case for https://github.com/psf/black/issues/4912 - unassigned long string with trailing comma
+"A long string literal that is not assigned to a variable, exceeds line length when string-processing is enabled, and has a trailing comma (to make it a one-item tuple)",
+
 func_with_keywords(my_arg, my_kwarg="Long keyword strings also need to be wrapped, but they will probably need to be handled a little bit differently.")
 
 bad_split1 = (
@@ -506,6 +509,13 @@ def foo():
     ),
 )
 
+# Test case for https://github.com/psf/black/issues/4912 - unassigned long string with trailing comma
+(
+    "A long string literal that is not assigned to a variable, exceeds line length when"
+    " string-processing is enabled, and has a trailing comma (to make it a one-item"
+    " tuple)"
+),
+
 func_with_keywords(
     my_arg,
     my_kwarg=(