Ruff formatter ignoring `fmt: skip`

[madduck]

Summary

Taking this over from #8415:

I have a little snippet that inserts ipdb into code, and I want to keep it on a single line, so that I can easily remove it again with Vim dd, here is the test-case:

def main() -> None:
    import ipdb; ipdb.set_trace()  # noqa: E402,E702,I001 fmt: skip

This passes ruff's check alright:

% ruff --isolated check test.py --fix 
All checks passed!

But when I run the formatter on it, it seems that fmt: skip is being ignored:

% ruff --isolated format test.py --diff
--- test.py
+++ test.py
@@ -1,2 +1,4 @@
 def main() -> None:
-    import ipdb; ipdb.set_trace()  # noqa: E402 E702 I001 # fmt: skip
+    import ipdb
+
+    ipdb.set_trace()  # noqa: E402 E702 I001 # fmt: skip

1 file would be reformatted

I have tried # fmt: skip before and after the noqa filter, I have tried two spaces before the #, and I have tried without noqa, i.e. just # fmt: skip, with and without a space after the colon — the same result for each of these permutations.

If I enclose the line in fmt:off and fmt:on statements, then the formatter finds nothing to do, but that defies the purpose of the single-line import, and the per-line fmt:skip instruction.

Version

0.11.4

[MichaReiser]

Thanks. I thought this is the same as #11216 but it's only related.

[madduck]

Is there anything I can do to expedite addressing of this bug?

[MichaReiser]

No. I don't think so. We have all the information we need. It's just that someone needs to find time to fix this.

[madduck]

No. I don't think so. We have all the information we need. It's just that someone needs to find time to fix this.

Ok. I don't know Rust too well, nor do I have ample free time, but if you pointed me in the right direction, I could take a look…?

[MichaReiser]

That's kind. I expect this fix to be somewhat involved. The best I can point you towards is

ruff/crates/ruff_python_formatter/src/comments/mod.rs

Lines 501 to 509 in 8c0743d

	pub(crate) fn has_skip_comment(trailing_comments: &[SourceComment], source: &str) -> bool {
	trailing_comments.iter().any(|comment| {
	comment.line_position().is_end_of_line()
	&& matches!(
	SuppressionKind::from_comment(comment.text(source)),
	Some(SuppressionKind::Skip | SuppressionKind::Off)
	)
	})
	}

. Then search where it is used

[MichaReiser]

I tried to implement this with claude but it struggled big times. But the tests are useful:

# Test cases for fmt: skip with compound statements (semicolon-separated statements)

# Simple assignment statements
a = 1
b = 2  # fmt: skip

# Import statements
import os
import sys  # fmt: skip

# Mixed statement types
x = 1
import json  # fmt: skip

# Import and function call
import ipdb

ipdb.set_trace()  # fmt: skip


# In function context
def test_function():
    import pdb

    pdb.set_trace()  # fmt: skip


# Original issue case
def main() -> None:
    import ipdb

    ipdb.set_trace()  # fmt: skip


# Test whitespace preservation - no space after semicolon
import json
import os  # fmt: skip

# Test whitespace preservation - multiple spaces after semicolon
import ast
import csv  # fmt: skip

# Test that both statements remain entirely unformatted
a.b
c   .   d  # fmt: skip

# Test with method calls - both should be unformatted
obj.method1()
obj2   .   method2(   arg  )  # fmt: skip

# Test with string concatenation - both should be unformatted
"hello" + "world"
"foo"    +    "bar"  # fmt: skip

# Test with list operations - both should be unformatted
[1, 2, 3]
[4,   5,6   ]  # fmt: skip

# Test with leading comment on first statement and trailing comment on second
# leading comment
x.y
z.w  # trailing comment and fmt: skip

# Should format normally when no fmt: skip (compare with above)
a.b
c.d

# Should still break lines when no fmt: skip
import os
import sys

# Should still break when only first statement has fmt: skip on separate line
import os  # fmt: skip
import sys

# Test cases with 3+ statements on single line with fmt: skip
a = 1
b = 2
c = 3  # fmt: skip

# Three imports
import os
import sys
import json  # fmt: skip

# Four mixed statements
x = 1
y = 2
import math

z = 3  # fmt: skip

# Five statements with various formatting
a = 1
b = 2
c = 3
d = 4
e    =    5  # fmt: skip

# Multiple method calls
obj.method1()
obj.method2()
obj.method3()
obj.method4()  # fmt: skip

# Mixed operations with whitespace preservation
[1, 2]
{"a": 1}
(3, 4)
x   +   y  # fmt: skip

# Many simple statements
a
b
c
d
e
f
g  # fmt: skip

# Function calls with arguments
print(1)
print(2, 3)
print(4, 5, 6)
print()  # fmt: skip


# In function context with multiple statements
def test_multiple():
    import pdb

    pdb.set_trace()
    x = 1
    y = 2  # fmt: skip


# Test cases where many statements are first in suite

# Module level - many statements as first statements in module
a = 1
b = 2
c = 3
d=4  # fmt: skip
regular_statement = "after compound"


# Function with many statements as first statements
def func_with_compound_first():
    x = 1
    y = 2
    z = 3
    w = 4
    v   =   5  # fmt: skip
    normal_statement = "after"


# Class with many statements as first statements
class ClassWithCompoundFirst:
    attr1 = 1
    attr2 = 2
    attr3=3  # fmt: skip

    def method(self):
        pass


# Nested function with compound first statements
def outer():
    def inner():
        import sys
        import os
        import json
        import ast  # fmt: skip

        return "done"

    return inner


# Class method with compound first statements
class TestClass:
    def method_with_compound_first(self):
        a = 1
        b = 2
        c    =    3  # fmt: skip
        return a + b + c


# Complex nesting - compound statements as first in various suites
if True:
    x = 1
    y = 2
    z = 3
    w = 4
    v = 5
    u=6  # fmt: skip
    print("after compound")

    def nested_func():
        import math
        import random
        from collections import defaultdict  # fmt: skip

        pass

    class NestedClass:
        value1 = 10
        value2 = 20
        value3 = 30
        value4=40  # fmt: skip


# Conditional with compound first statements
if True:
    first = 1
    second = 2
    third = 3
    fourth = 4
    fifth=5  # fmt: skip
elif False:
    alt1 = 10
    alt2 = 20
    alt3=30  # fmt: skip
else:
    else1 = 100
    else2 = 200
    else3 = 300
    else4=400  # fmt: skip

# Loop with compound first statements
for i in range(3):
    loop_var1 = i
    loop_var2 = i * 2
    loop_var3 = i * 3
    loop_var4=i*4  # fmt: skip

# While loop with compound first statements
while False:
    while_var1 = 1
    while_var2 = 2
    while_var3=3  # fmt: skip

# Try block with compound first statements
try:
    try_var1 = 1
    try_var2 = 2
    try_var3 = 3
    try_var4 = 4
    try_var5=5  # fmt: skip
except:
    except_var1 = 1
    except_var2 = 2
    except_var3=3  # fmt: skip
finally:
    finally_var1 = 1
    finally_var2=2  # fmt: skip

# With statement with compound first statements
with open("test.txt") as f:
    with_var1 = 1
    with_var2 = 2
    with_var3 = 3
    with_var4=4  # fmt: skip

And we probably need to integrate this into FormatSuite