Trailing comma in `case` pattern causes `if` guard to explode

[dosisod]

Black is exploding the if guard in case patterns which have trailing commas in them, even if the guard expression fits in one line. The trailing comma logic should apply only to the case pattern, not the if guard.

Black d0ff3b

Playground link

Options

--line-length=88
--safe

Input

def f(x):
    match x:
        # good refactor
        case [
            y
        ] if y == 123:
            pass

        case [
            y
        ] if True:
            pass

        case [
            y,
        ] if True:
            pass

        # bad refactor
        case [
            y,
        ] if y == 123:
            pass

Output

def f(x):
    match x:
        # good refactor
        case [y] if y == 123:
            pass

        case [y] if True:
            pass

        case [
            y,
        ] if True:
            pass

        # bad refactor
        case [
            y,
        ] if (
            y == 123
        ):
            pass

Expected

This case:

    match x:
        case [
            y,
        ] if y == 123:
            pass

Should not be refactored, as the if guard can fit on one line. The pattern above is forcing a refactor as it has a trailing comma, which should not happen as the pattern and the guard are separate expressions. Using --skip-magic-trailing-comma "fixes" this, but also causes trailing commas to be ignored globally, which is not desirable.

I didn't catch this when I wrote #4214 because this issue only crops up when the pattern has trailing commas, and the if guard is a more complex expression.

Since I wrote #4214 I can fix this one as well.

[NMMashilheiba]

Any further explanation on this issue??

[dosisod]

@NMMashilheiba Here are some other examples of Python syntax which is similar to the case/if syntax, but isn't being exploded like above:

def f(x):
    return (
        [
            1,
        ]
        if x == 123  # `x == 123` is not wrapped/exploded
        else []
    )


def f2(x):
    return x == 123 or [  # `x == 123` is not wrapped/exploded
        1,
    ]


def f3(x):
    return [
        1,
    ] or x == 123  # `x == 123` is not wrapped/exploded


def f4(x):
    match x:
        case [
            1,
        ] if x == 123:  # `x == 123` IS wrapped and exploded
            pass

When running with Black 25.1.0, you get the following output:

$ black x.py --check --diff
--- x.py        2025-04-30 20:54:43.315322+00:00
+++ x.py        2025-04-30 20:54:45.936307+00:00
@@ -22,7 +22,9 @@

 def f4(x):
     match x:
         case [
             1,
-        ] if x == 123:  # `x == 123` IS wrapped and exploded
+        ] if (
+            x == 123
+        ):  # `x == 123` IS wrapped and exploded
             pass

The only piece of code that gets changed is f4().

Essentially, the case pattern and the if guard expression should be treated as separate expressions. The issue is that when the pattern has a trailing comma, the if guard always gets exploded.

For example, if you remove the trailing comma in the f4 example, Black will collapse everything:

def f5(x):
    match x:
        case [
            1,
            2
        ] if (
            x == 123
        ):
            pass

 def f5(x):
     match x:
-        case [
-            1,
-            2
-        ] if (
-            x == 123
-        ):
+        case [1, 2] if x == 123:
             pass

Hopefully that helps!

Sorry if you got pinged twice, I wrote my first comment on my work account and then deleted/re-posted it

[NMMashilheiba]

I would love to see how this issue can be fixed. Hope someone fix this.

[JelleZijlstra]

PR welcome!