Fix self

This PR adjusts the logic for skipping formatting so that a `fmt: skip`
can affect multiple statements if they lie on the same line.

Specifically, a `fmt: skip` comment will now suppress all the statements
in the suite in which it appears whose range intersects the line
containing the skip directive. For example:

```python
x=[
'1'
];x=2 # fmt: skip
```

remains unchanged after formatting.

(Note that compound statements are somewhat special and were handled in
a previous PR - see #20633).


Closes #17331 and #11430.

Simplest to review commit by commit - the key diffs of interest are the
commit introducing the core logic, and the diff between the snapshots
introduced in the last commit (compared to the second commit).

# Implementation

On `main` we format a suite of statements by iterating through them. If
we meet a statement with a leading or trailing (own-line)`fmt: off`
comment, then we suppress formatting until we meet a `fmt: on` comment.
Otherwise we format the statement using its own formatting rule.

How are `fmt: skip` comments handled then? They are handled internally
to the formatting of each statement. Specifically, calling `.fmt` on a
statement node will first check to see if there is a trailing,
end-of-line `fmt: skip` (or `fmt: off`/`yapf: off`), and if so then
write the node with suppressed formatting.

In this PR we move the responsibility for handling `fmt: skip` into the
formatting logic of the suite itself. This is done as follows:

- Before beginning to format the suite, we do a pass through the
statements and collect the data of ranges with skipped formatting. More
specifically, we create a map with key given by the _first_ skipped
statement in a block and value a pair consisting of the _last_ skipped
statement and the _range_ to write verbatim.
- We iterate as before, but if we meet a statement that is a key in the
map constructed above, we pause to write the associated range verbatim.
We then advance the iterator to the last statement in the block and
proceed as before.

## Addendum on range formatting

We also had to make some changes to range formatting in order to support
this new behavior. For example, we want to make sure that

```python
<RANGE_START>x=1<RANGE_END>;x=2 # fmt: skip
```

formats verbatim, rather than becoming 

```python
x = 1;x=2 # fmt: skip
```

Recall that range formatting proceeds in two steps:
1. Find the smallest enclosing node containing the range AND that has
enough info to format the range (so it may be larger than you think,
e.g. a docstring has enclosing node given by the suite, not the string
itself.)
2. Carve out the formatted range from the result of formatting that
enclosing node.

We had to modify (1), since the suite knows how to format skipped nodes,
but nodes may not "know" they are skipped. To do this we altered the
`visit_body` bethod of the `FindEnclosingNode` visitor: now we iterate
through the statements and check for skipped ranges intersecting the
format range. If we find them, we return without descending. The result
is to consider the statement containing the suite as the enclosing node
in this case.

crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_skip/semicolons.py

@@ -0,0 +1,133 @@
+class Simple:
+    x=1
+    x=2 # fmt: skip
+    x=3
+
+class Semicolon:
+    x=1
+    x=2;x=3 # fmt: skip
+    x=4
+
+class TrailingSemicolon:
+    x=1
+    x=2;x=3    ; # fmt: skip
+    x=4
+
+class SemicolonNewLogicalLine:
+    x=1;
+    x=2;x=3 # fmt: skip
+    x=4
+
+class ManySemicolonOneLine:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class CompoundInSuite:
+    x=1
+    def foo(): y=1 # fmt: skip
+    x=2
+
+class CompoundInSuiteNewline:
+    x=1
+    def foo():
+        y=1 # fmt: skip
+    x=2
+
+class MultiLineSkip:
+    x=1
+    x = [
+        '1',
+        '2',
+    ] # fmt: skip
+
+class MultiLineSemicolon:
+    x=1
+    x = [
+        '1',
+        '2',
+    ]; x=2 # fmt: skip
+
+class LineContinuationSemicolonAfter:
+    x=1
+    x = ['a']\
+    ; y=1 # fmt: skip
+
+class LineContinuationSemicolonBefore:
+    x=1
+    x = ['a']; \
+    y=1 # fmt: skip
+
+class LineContinuationSemicolonAndNewline:
+    x=1
+    x = ['a']; \
+
+    y=1 # fmt: skip
+
+class LineContinuationSemicolonAndNewlineAndComment:
+    x=1
+    x = ['a']; \
+    # 1
+    y=1 # fmt: skip
+
+class RepeatedLineContinuation:
+    x=1
+    x = ['a']; \
+    \
+    \
+    y=1 # fmt: skip
+
+class MultiLineSemicolonComments:
+    x=1
+          # 1
+    x = [     # 2
+        '1',    # 3
+        '2',
+            # 4
+    ]; x=2    # 5   # fmt: skip    # 6
+
+class DocstringSkipped:
+    '''This is a docstring''' # fmt: skip
+    x=1
+
+class MultilineDocstringSkipped:
+    '''This is a docstring
+    ''' # fmt: skip
+    x=1
+
+class FirstStatementNewlines:
+
+
+
+
+    x=1 # fmt: skip
+
+class ChainingSemicolons:
+    x=[
+        '1',
+        '2',
+        '3',
+    ];x=1;x=[
+        '1',
+        '2',
+        '3'
+    ];x=1;x=1 # fmt: skip
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3
+        '2',
+        '3'
+    ]    ;x=2;x=3 # 4 # fmt: skip # 5
+    # 6
+
+class MixingCompound:
+    def foo(): bar(); import zoo # fmt: skip
+
+# https://github.com/astral-sh/ruff/issues/17331
+def main() -> None:
+    import ipdb; ipdb.set_trace()  # noqa: E402,E702,I001 # fmt: skip
+
+# https://github.com/astral-sh/ruff/issues/11430
+print(); print() # noqa # fmt: skip

crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_skip/top_level_semicolon.py

@@ -0,0 +1,22 @@
+    # 0
+'''Module docstring
+multiple lines'''      # 1 # fmt: skip # 2
+
+import a;import b; from c import (
+        x,y,z
+    ); import f # fmt: skip
+
+x=1;x=2;x=3;x=4 # fmt: skip
+
+   # 1
+x=[     # 2
+    '1',       # 3
+    '2',
+    '3'
+];x=1;x=1 # 4 # fmt: skip # 5
+   # 6
+
+def foo(): x=[
+    '1',
+    '2',
+];x=1 # fmt: skip

crates/ruff_python_formatter/resources/test/fixtures/ruff/range_formatting/fmt_skip.py

@@ -0,0 +1,68 @@
+class Simple:
+    # Range comprises skip range
+    x=1
+    <RANGE_START>x=2 <RANGE_END># fmt: skip
+    x=3
+
+class Semicolon:
+    # Range is part of skip range
+    x=1
+    x=2;<RANGE_START>x=3<RANGE_END> # fmt: skip
+    x=4
+
+class FormatFirst:
+    x=1
+    <RANGE_START>x=2<RANGE_END>;x=3 # fmt: skip
+    x=4
+
+class FormatMiddle:
+    x=1
+    x=2;<RANGE_START>x=3<RANGE_END>;x=4 # fmt: skip
+    x=5
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on right side
+    <RANGE_START>x=1;
+    x=2<RANGE_END>;x=3 # fmt: skip
+    x=4
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on left side
+    x=1;
+    x=2;<RANGE_START>x=3 # fmt: skip
+    x=4<RANGE_END>
+
+class ManySemicolonOneLine:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class CompoundInSuite:
+    x=1
+    <RANGE_START>def foo(): y=1 <RANGE_END># fmt: skip
+    x=2
+
+class CompoundInSuiteNewline:
+    x=1
+    def foo():
+        y=1 # fmt: skip
+    x=2
+
+class MultiLineSkip:
+    # Range inside statement
+    x=1
+    x = <RANGE_START>[
+        '1',
+        '2',<RANGE_END>
+    ] # fmt: skip
+
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3<RANGE_START>
+        '2',
+        '3'
+    ]    ;x=2;x=3 # 4<RANGE_END> # fmt: skip # 5
+    # 6
+

crates/ruff_python_formatter/src/lib.rs

@@ -24,7 +24,6 @@ pub use crate::options::{
 };
 use crate::range::is_logical_line;
 pub use crate::shared_traits::{AsFormat, FormattedIter, FormattedIterExt, IntoFormat};
-use crate::verbatim::suppressed_node;
 
 pub(crate) mod builders;
 pub mod cli;
@@ -61,51 +60,39 @@ where
         let node_ref = AnyNodeRef::from(node);
         let node_comments = comments.leading_dangling_trailing(node_ref);
 
-        if self.is_suppressed(node_comments.trailing, f.context()) {
-            suppressed_node(node_ref).fmt(f)
-        } else {
-            leading_comments(node_comments.leading).fmt(f)?;
+        leading_comments(node_comments.leading).fmt(f)?;
 
-            // Emit source map information for nodes that are valid "narrowing" targets
-            // in range formatting. Never emit source map information if they're disabled
-            // for performance reasons.
-            let emit_source_position = (is_logical_line(node_ref) || node_ref.is_mod_module())
-                && f.options().source_map_generation().is_enabled();
+        // Emit source map information for nodes that are valid "narrowing" targets
+        // in range formatting. Never emit source map information if they're disabled
+        // for performance reasons.
+        let emit_source_position = (is_logical_line(node_ref) || node_ref.is_mod_module())
+            && f.options().source_map_generation().is_enabled();
 
-            emit_source_position
-                .then_some(source_position(node.start()))
-                .fmt(f)?;
+        emit_source_position
+            .then_some(source_position(node.start()))
+            .fmt(f)?;
 
-            self.fmt_fields(node, f)?;
+        self.fmt_fields(node, f)?;
 
-            debug_assert!(
-                node_comments
-                    .dangling
-                    .iter()
-                    .all(SourceComment::is_formatted),
-                "The node has dangling comments that need to be formatted manually. Add the special dangling comments handling to `fmt_fields`."
-            );
+        debug_assert!(
+            node_comments
+                .dangling
+                .iter()
+                .all(SourceComment::is_formatted),
+            "The node has dangling comments that need to be formatted manually. Add the special dangling comments handling to `fmt_fields`."
+        );
 
-            write!(
-                f,
-                [
-                    emit_source_position.then_some(source_position(node.end())),
-                    trailing_comments(node_comments.trailing)
-                ]
-            )
-        }
+        write!(
+            f,
+            [
+                emit_source_position.then_some(source_position(node.end())),
+                trailing_comments(node_comments.trailing)
+            ]
+        )
     }
 
     /// Formats the node's fields.
     fn fmt_fields(&self, item: &N, f: &mut PyFormatter) -> FormatResult<()>;
-
-    fn is_suppressed(
-        &self,
-        _trailing_comments: &[SourceComment],
-        _context: &PyFormatContext,
-    ) -> bool {
-        false
-    }
 }
 
 #[derive(Error, Debug, salsa::Update, PartialEq, Eq)]

crates/ruff_python_formatter/src/other/decorator.rs

@@ -1,9 +1,10 @@
 use ruff_formatter::write;
 use ruff_python_ast::Decorator;
+use ruff_text_size::Ranged;
 
-use crate::comments::SourceComment;
 use crate::expression::maybe_parenthesize_expression;
 use crate::expression::parentheses::Parenthesize;
+use crate::verbatim::verbatim_text;
 use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
@@ -11,26 +12,27 @@ pub struct FormatDecorator;
 
 impl FormatNodeRule<Decorator> for FormatDecorator {
     fn fmt_fields(&self, item: &Decorator, f: &mut PyFormatter) -> FormatResult<()> {
-        let Decorator {
-            expression,
-            range: _,
-            node_index: _,
-        } = item;
+        let comments = f.context().comments();
+        let trailing = comments.trailing(item);
 
-        write!(
-            f,
-            [
-                token("@"),
-                maybe_parenthesize_expression(expression, item, Parenthesize::Optional)
-            ]
-        )
-    }
+        if has_skip_comment(trailing, f.context().source()) {
+            comments.mark_verbatim_node_comments_formatted(item.into());
 
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
+            verbatim_text(item.range()).fmt(f)
+        } else {
+            let Decorator {
+                expression,
+                range: _,
+                node_index: _,
+            } = item;
+
+            write!(
+                f,
+                [
+                    token("@"),
+                    maybe_parenthesize_expression(expression, item, Parenthesize::Optional)
+                ]
+            )
+        }
     }
 }

crates/ruff_python_formatter/src/range.rs

@@ -15,7 +15,7 @@ use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 use crate::comments::Comments;
 use crate::context::{IndentLevel, NodeLevel};
 use crate::prelude::*;
-use crate::statement::suite::DocstringStmt;
+use crate::statement::suite::{DocstringStmt, skip_range};
 use crate::verbatim::{ends_suppression, starts_suppression};
 use crate::{FormatModuleError, PyFormatOptions, format_module_source};
 
@@ -251,7 +251,29 @@ impl<'ast> SourceOrderVisitor<'ast> for FindEnclosingNode<'_, 'ast> {
         // We only visit statements that aren't suppressed that's why we don't need to track the suppression
         // state in a stack. Assert that this assumption is safe.
         debug_assert!(self.suppressed.is_no());
-        walk_body(self, body);
+
+        let mut iter = body.iter();
+
+        while let Some(stmt) = iter.next() {
+            // If the range intersects a skip range then we need to
+            // format the entire suite to properly handle the case
+            // where a `fmt: skip` affects multiple statements.
+            //
+            // For example, in the case
+            //
+            // ```
+            // <RANGE_START>x=1<RANGE_END>;x=2 # fmt: skip
+            // ```
+            //
+            // the statement `x=1` does not "know" that it is
+            // suppressed, but the suite does.
+            if let Some(verbatim_range) = skip_range(stmt, iter.as_slice(), self.context)
+                && verbatim_range.intersect(self.range).is_some()
+            {
+                break;
+            }
+            self.visit_stmt(stmt);
+        }
         self.suppressed = Suppressed::No;
     }
 }
@@ -561,7 +583,7 @@ impl NarrowRange<'_> {
 }
 
 pub(crate) const fn is_logical_line(node: AnyNodeRef) -> bool {
-    // Make sure to update [`FormatEnclosingLine`] when changing this.
+    // Make sure to update [`FormatEnclosingNode`] when changing this.
     node.is_statement()
         || node.is_decorator()
         || node.is_except_handler()

crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs

@@ -1,14 +1,13 @@
 use ruff_formatter::write;
 use ruff_python_ast::StmtAnnAssign;
 
-use crate::comments::SourceComment;
 use crate::expression::is_splittable_expression;
 use crate::expression::parentheses::Parentheses;
+use crate::prelude::*;
 use crate::statement::stmt_assign::{
     AnyAssignmentOperator, AnyBeforeOperator, FormatStatementsLastExpression,
 };
 use crate::statement::trailing_semicolon;
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtAnnAssign;
@@ -84,12 +83,4 @@ impl FormatNodeRule<StmtAnnAssign> for FormatStmtAnnAssign {
 
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_assert.rs

@@ -2,10 +2,9 @@ use ruff_formatter::prelude::{space, token};
 use ruff_formatter::write;
 use ruff_python_ast::StmtAssert;
 
-use crate::comments::SourceComment;
 use crate::expression::maybe_parenthesize_expression;
 use crate::expression::parentheses::Parenthesize;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtAssert;
@@ -41,12 +40,4 @@ impl FormatNodeRule<StmtAssert> for FormatStmtAssert {
 
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_assign.rs

@@ -19,6 +19,7 @@ use crate::expression::{
     maybe_parenthesize_expression,
 };
 use crate::other::interpolated_string::InterpolatedStringLayout;
+use crate::prelude::*;
 use crate::preview::is_parenthesize_lambda_bodies_enabled;
 use crate::statement::trailing_semicolon;
 use crate::string::StringLikeExtensions;
@@ -26,7 +27,6 @@ use crate::string::implicit::{
     FormatImplicitConcatenatedStringExpanded, FormatImplicitConcatenatedStringFlat,
     ImplicitConcatenatedLayout,
 };
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtAssign;
@@ -104,14 +104,6 @@ impl FormatNodeRule<StmtAssign> for FormatStmtAssign {
 
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }
 
 /// Formats a single target with the equal operator.

crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs

@@ -1,15 +1,14 @@
 use ruff_formatter::write;
 use ruff_python_ast::StmtAugAssign;
 
-use crate::comments::SourceComment;
 use crate::expression::parentheses::is_expression_parenthesized;
+use crate::prelude::*;
 use crate::statement::stmt_assign::{
     AnyAssignmentOperator, AnyBeforeOperator, FormatStatementsLastExpression,
     has_target_own_parentheses,
 };
 use crate::statement::trailing_semicolon;
 use crate::{AsFormat, FormatNodeRule};
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtAugAssign;
@@ -62,12 +61,4 @@ impl FormatNodeRule<StmtAugAssign> for FormatStmtAugAssign {
 
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_break.rs

@@ -1,7 +1,6 @@
 use ruff_python_ast::StmtBreak;
 
-use crate::comments::SourceComment;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtBreak;
@@ -10,12 +9,4 @@ impl FormatNodeRule<StmtBreak> for FormatStmtBreak {
     fn fmt_fields(&self, _item: &StmtBreak, f: &mut PyFormatter) -> FormatResult<()> {
         token("break").fmt(f)
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_continue.rs

@@ -1,7 +1,6 @@
 use ruff_python_ast::StmtContinue;
 
-use crate::comments::SourceComment;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtContinue;
@@ -10,12 +9,4 @@ impl FormatNodeRule<StmtContinue> for FormatStmtContinue {
     fn fmt_fields(&self, _item: &StmtContinue, f: &mut PyFormatter) -> FormatResult<()> {
         token("continue").fmt(f)
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_delete.rs

@@ -3,10 +3,10 @@ use ruff_python_ast::StmtDelete;
 use ruff_text_size::Ranged;
 
 use crate::builders::{PyFormatterExtensions, parenthesize_if_expands};
-use crate::comments::{SourceComment, dangling_node_comments};
+use crate::comments::dangling_node_comments;
 use crate::expression::maybe_parenthesize_expression;
 use crate::expression::parentheses::Parenthesize;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtDelete;
@@ -57,12 +57,4 @@ impl FormatNodeRule<StmtDelete> for FormatStmtDelete {
             }
         }
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_expr.rs

@@ -1,12 +1,10 @@
 use ruff_python_ast as ast;
 use ruff_python_ast::{Expr, Operator, StmtExpr};
 
-use crate::comments::SourceComment;
-
 use crate::expression::maybe_parenthesize_expression;
 use crate::expression::parentheses::Parenthesize;
+use crate::prelude::*;
 use crate::statement::trailing_semicolon;
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtExpr;
@@ -30,14 +28,6 @@ impl FormatNodeRule<StmtExpr> for FormatStmtExpr {
 
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }
 
 const fn is_arithmetic_like(expression: &Expr) -> bool {

crates/ruff_python_formatter/src/statement/stmt_global.rs

@@ -1,8 +1,6 @@
 use ruff_formatter::{format_args, write};
 use ruff_python_ast::StmtGlobal;
 
-use crate::comments::SourceComment;
-use crate::has_skip_comment;
 use crate::prelude::*;
 
 #[derive(Default)]
@@ -47,12 +45,4 @@ impl FormatNodeRule<StmtGlobal> for FormatStmtGlobal {
             )
         }
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_import.rs

@@ -1,8 +1,7 @@
 use ruff_formatter::{format_args, write};
 use ruff_python_ast::StmtImport;
 
-use crate::comments::SourceComment;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtImport;
@@ -21,12 +20,4 @@ impl FormatNodeRule<StmtImport> for FormatStmtImport {
         });
         write!(f, [token("import"), space(), names])
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_import_from.rs

@@ -3,9 +3,7 @@ use ruff_python_ast::StmtImportFrom;
 use ruff_text_size::Ranged;
 
 use crate::builders::{PyFormatterExtensions, TrailingComma, parenthesize_if_expands};
-use crate::comments::SourceComment;
 use crate::expression::parentheses::parenthesized;
-use crate::has_skip_comment;
 use crate::other::identifier::DotDelimitedIdentifier;
 use crate::prelude::*;
 
@@ -72,12 +70,4 @@ impl FormatNodeRule<StmtImportFrom> for FormatStmtImportFrom {
                 .fmt(f)
         }
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_ipy_escape_command.rs

@@ -1,8 +1,7 @@
 use ruff_python_ast::StmtIpyEscapeCommand;
 use ruff_text_size::Ranged;
 
-use crate::comments::SourceComment;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtIpyEscapeCommand;
@@ -11,12 +10,4 @@ impl FormatNodeRule<StmtIpyEscapeCommand> for FormatStmtIpyEscapeCommand {
     fn fmt_fields(&self, item: &StmtIpyEscapeCommand, f: &mut PyFormatter) -> FormatResult<()> {
         source_text_slice(item.range()).fmt(f)
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs

@@ -1,8 +1,6 @@
 use ruff_formatter::{format_args, write};
 use ruff_python_ast::StmtNonlocal;
 
-use crate::comments::SourceComment;
-use crate::has_skip_comment;
 use crate::prelude::*;
 
 #[derive(Default)]
@@ -47,12 +45,4 @@ impl FormatNodeRule<StmtNonlocal> for FormatStmtNonlocal {
             )
         }
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_pass.rs

@@ -1,7 +1,6 @@
 use ruff_python_ast::StmtPass;
 
-use crate::comments::SourceComment;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtPass;
@@ -10,12 +9,4 @@ impl FormatNodeRule<StmtPass> for FormatStmtPass {
     fn fmt_fields(&self, _item: &StmtPass, f: &mut PyFormatter) -> FormatResult<()> {
         token("pass").fmt(f)
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_raise.rs

@@ -1,10 +1,9 @@
 use ruff_formatter::write;
 use ruff_python_ast::StmtRaise;
 
-use crate::comments::SourceComment;
 use crate::expression::maybe_parenthesize_expression;
 use crate::expression::parentheses::Parenthesize;
-use crate::{has_skip_comment, prelude::*};
+use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatStmtRaise;
@@ -43,12 +42,4 @@ impl FormatNodeRule<StmtRaise> for FormatStmtRaise {
         }
         Ok(())
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_return.rs

@@ -1,10 +1,9 @@
 use ruff_formatter::write;
 use ruff_python_ast::{Expr, StmtReturn};
 
-use crate::comments::SourceComment;
 use crate::expression::expr_tuple::TupleParentheses;
+use crate::prelude::*;
 use crate::statement::stmt_assign::FormatStatementsLastExpression;
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtReturn;
@@ -43,12 +42,4 @@ impl FormatNodeRule<StmtReturn> for FormatStmtReturn {
             None => Ok(()),
         }
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/stmt_type_alias.rs

@@ -1,11 +1,10 @@
 use ruff_formatter::write;
 use ruff_python_ast::StmtTypeAlias;
 
-use crate::comments::SourceComment;
+use crate::prelude::*;
 use crate::statement::stmt_assign::{
     AnyAssignmentOperator, AnyBeforeOperator, FormatStatementsLastExpression,
 };
-use crate::{has_skip_comment, prelude::*};
 
 #[derive(Default)]
 pub struct FormatStmtTypeAlias;
@@ -42,12 +41,4 @@ impl FormatNodeRule<StmtTypeAlias> for FormatStmtTypeAlias {
             ]
         )
     }
-
-    fn is_suppressed(
-        &self,
-        trailing_comments: &[SourceComment],
-        context: &PyFormatContext,
-    ) -> bool {
-        has_skip_comment(trailing_comments, context.source())
-    }
 }

crates/ruff_python_formatter/src/statement/suite.rs

@@ -4,11 +4,15 @@ use ruff_formatter::{
 use ruff_python_ast::helpers::is_compound_statement;
 use ruff_python_ast::{self as ast, Expr, PySourceType, Stmt, Suite};
 use ruff_python_ast::{AnyNodeRef, StmtExpr};
-use ruff_python_trivia::{lines_after, lines_after_ignoring_end_of_line_trivia, lines_before};
+use ruff_python_trivia::{
+    SimpleTokenKind, SimpleTokenizer, lines_after, lines_after_ignoring_end_of_line_trivia,
+    lines_before,
+};
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::comments::{
-    Comments, LeadingDanglingTrailingComments, leading_comments, trailing_comments,
+    Comments, LeadingDanglingTrailingComments, has_skip_comment, leading_comments,
+    trailing_comments,
 };
 use crate::context::{NodeLevel, TopLevelStatementPosition, WithIndentLevel, WithNodeLevel};
 use crate::other::string_literal::StringLiteralKind;
@@ -16,9 +20,9 @@ use crate::prelude::*;
 use crate::preview::{
     is_allow_newline_after_block_open_enabled, is_blank_line_before_decorated_class_in_stub_enabled,
 };
-use crate::statement::stmt_expr::FormatStmtExpr;
+use crate::statement::trailing_semicolon;
 use crate::verbatim::{
-    suppressed_node, write_suppressed_statements_starting_with_leading_comment,
+    write_skipped_statements, write_suppressed_statements_starting_with_leading_comment,
     write_suppressed_statements_starting_with_trailing_comment,
 };
 
@@ -152,7 +156,21 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
 
         let first_comments = comments.leading_dangling_trailing(first);
 
-        let (mut preceding, mut empty_line_after_docstring) = if first_comments
+        let (mut preceding, mut empty_line_after_docstring) = if let Some(verbatim_range) =
+            skip_range(first.statement(), iter.as_slice(), f.context())
+        {
+            let preceding =
+                write_skipped_statements(first.statement(), &mut iter, verbatim_range, f)?;
+
+            // Insert a newline after a module level docstring, but treat
+            // it as a docstring otherwise. See: https://github.com/psf/black/pull/3932.
+            let empty_line_after_docstring =
+                matches!(self.kind, SuiteKind::TopLevel | SuiteKind::Class)
+                    && DocstringStmt::try_from_statement(preceding, self.kind, f.context())
+                        .is_some();
+
+            (preceding, empty_line_after_docstring)
+        } else if first_comments
             .leading
             .iter()
             .any(|comment| comment.is_suppression_off_comment(source))
@@ -391,7 +409,10 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
                 }
             }
 
-            if following_comments
+            if let Some(verbatim_range) = skip_range(following, iter.as_slice(), f.context()) {
+                preceding = write_skipped_statements(following, &mut iter, verbatim_range, f)?;
+                preceding_comments = comments.leading_dangling_trailing(preceding);
+            } else if following_comments
                 .leading
                 .iter()
                 .any(|comment| comment.is_suppression_off_comment(source))
@@ -840,61 +861,57 @@ impl Format<PyFormatContext<'_>> for DocstringStmt<'_> {
         let comments = f.context().comments().clone();
         let node_comments = comments.leading_dangling_trailing(self.docstring);
 
-        if FormatStmtExpr.is_suppressed(node_comments.trailing, f.context()) {
-            suppressed_node(self.docstring).fmt(f)
-        } else {
-            // SAFETY: Safe because `DocStringStmt` guarantees that it only ever wraps a `ExprStmt` containing a `ExprStringLiteral`.
-            let string_literal = self
-                .docstring
-                .as_expr_stmt()
-                .unwrap()
-                .value
-                .as_string_literal_expr()
-                .unwrap();
+        // SAFETY: Safe because `DocStringStmt` guarantees that it only ever wraps a `ExprStmt` containing a `ExprStringLiteral`.
+        let string_literal = self
+            .docstring
+            .as_expr_stmt()
+            .unwrap()
+            .value
+            .as_string_literal_expr()
+            .unwrap();
 
-            // We format the expression, but the statement carries the comments
-            write!(
-                f,
-                [
-                    leading_comments(node_comments.leading),
-                    f.options()
-                        .source_map_generation()
-                        .is_enabled()
-                        .then_some(source_position(self.docstring.start())),
-                    string_literal
-                        .format()
-                        .with_options(StringLiteralKind::Docstring),
-                    f.options()
-                        .source_map_generation()
-                        .is_enabled()
-                        .then_some(source_position(self.docstring.end())),
-                ]
-            )?;
+        // We format the expression, but the statement carries the comments
+        write!(
+            f,
+            [
+                leading_comments(node_comments.leading),
+                f.options()
+                    .source_map_generation()
+                    .is_enabled()
+                    .then_some(source_position(self.docstring.start())),
+                string_literal
+                    .format()
+                    .with_options(StringLiteralKind::Docstring),
+                f.options()
+                    .source_map_generation()
+                    .is_enabled()
+                    .then_some(source_position(self.docstring.end())),
+            ]
+        )?;
 
-            if self.suite_kind == SuiteKind::Class {
-                // Comments after class docstrings need a newline between the docstring and the
-                // comment (https://github.com/astral-sh/ruff/issues/7948).
-                // ```python
-                // class ModuleBrowser:
-                //     """Browse module classes and functions in IDLE."""
-                //     # ^ Insert a newline above here
-                //
-                //     def __init__(self, master, path, *, _htest=False, _utest=False):
-                //         pass
-                // ```
-                if let Some(own_line) = node_comments
-                    .trailing
-                    .iter()
-                    .find(|comment| comment.line_position().is_own_line())
-                {
-                    if lines_before(own_line.start(), f.context().source()) < 2 {
-                        empty_line().fmt(f)?;
-                    }
+        if self.suite_kind == SuiteKind::Class {
+            // Comments after class docstrings need a newline between the docstring and the
+            // comment (https://github.com/astral-sh/ruff/issues/7948).
+            // ```python
+            // class ModuleBrowser:
+            //     """Browse module classes and functions in IDLE."""
+            //     # ^ Insert a newline above here
+            //
+            //     def __init__(self, master, path, *, _htest=False, _utest=False):
+            //         pass
+            // ```
+            if let Some(own_line) = node_comments
+                .trailing
+                .iter()
+                .find(|comment| comment.line_position().is_own_line())
+            {
+                if lines_before(own_line.start(), f.context().source()) < 2 {
+                    empty_line().fmt(f)?;
                 }
             }
-
-            trailing_comments(node_comments.trailing).fmt(f)
         }
+
+        trailing_comments(node_comments.trailing).fmt(f)
     }
 }
 
@@ -938,6 +955,58 @@ impl Format<PyFormatContext<'_>> for SuiteChildStatement<'_> {
     }
 }
 
+pub(crate) fn skip_range(
+    first: &Stmt,
+    statements: &[Stmt],
+    context: &PyFormatContext,
+) -> Option<TextRange> {
+    let start = first.start();
+    let mut last_statement = first;
+
+    let comments = context.comments();
+    let source = context.source();
+
+    for statement in statements {
+        if new_logical_line_between_statements(
+            source,
+            TextRange::new(last_statement.end(), statement.start()),
+        ) {
+            break;
+        }
+        last_statement = statement;
+    }
+
+    if has_skip_comment(comments.trailing(last_statement), source) {
+        Some(TextRange::new(
+            start,
+            trailing_semicolon(last_statement.into(), source)
+                .map_or_else(|| last_statement.end(), ruff_text_size::TextRange::end),
+        ))
+    } else {
+        None
+    }
+}
+
+fn new_logical_line_between_statements(source: &str, between_statement_range: TextRange) -> bool {
+    let mut tokenizer = SimpleTokenizer::new(source, between_statement_range).map(|tok| tok.kind());
+
+    while let Some(token) = tokenizer.next() {
+        match token {
+            SimpleTokenKind::Continuation => {
+                tokenizer.next();
+            }
+            SimpleTokenKind::Newline => {
+                return true;
+            }
+            // Since we are between statements, there are
+            // no non-trivia tokens, so there is no need to check
+            // for these and do an early return.
+            _ => {}
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests {
     use ruff_formatter::format;

crates/ruff_python_formatter/src/verbatim.rs

@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::iter::FusedIterator;
 use std::slice::Iter;
 
+use itertools::PeekingNext;
 use ruff_formatter::{FormatError, write};
 use ruff_python_ast::AnyNodeRef;
 use ruff_python_ast::Stmt;
@@ -451,6 +452,40 @@ fn write_suppressed_statements<'a>(
     }
 }
 
+#[cold]
+pub(crate) fn write_skipped_statements<'a>(
+    first_skipped: &'a Stmt,
+    statements: &mut std::slice::Iter<'a, Stmt>,
+    verbatim_range: TextRange,
+    f: &mut PyFormatter,
+) -> FormatResult<&'a Stmt> {
+    let comments = f.context().comments().clone();
+    comments.mark_verbatim_node_comments_formatted(first_skipped.into());
+
+    let mut preceding = first_skipped;
+
+    while let Some(prec) = statements.peeking_next(|next| next.end() <= verbatim_range.end()) {
+        comments.mark_verbatim_node_comments_formatted(prec.into());
+        preceding = prec;
+    }
+
+    let first_leading = comments.leading(first_skipped);
+    let preceding_trailing = comments.trailing(preceding);
+
+    // Write the outer comments and format the node as verbatim
+    write!(
+        f,
+        [
+            leading_comments(first_leading),
+            source_position(verbatim_range.start()),
+            verbatim_text(verbatim_range),
+            source_position(verbatim_range.end()),
+            trailing_comments(preceding_trailing)
+        ]
+    )?;
+    Ok(preceding)
+}
+
 #[derive(Copy, Clone, Debug)]
 enum InSuppression {
     No,
@@ -893,65 +928,6 @@ impl Format<PyFormatContext<'_>> for VerbatimText {
     }
 }
 
-/// Disables formatting for `node` and instead uses the same formatting as the node has in source.
-///
-/// The `node` gets indented as any formatted node to avoid syntax errors when the indentation string changes (e.g. from 2 spaces to 4).
-/// The `node`s leading and trailing comments are formatted as usual, except if they fall into the suppressed node's range.
-#[cold]
-pub(crate) fn suppressed_node<'a, N>(node: N) -> FormatSuppressedNode<'a>
-where
-    N: Into<AnyNodeRef<'a>>,
-{
-    FormatSuppressedNode { node: node.into() }
-}
-
-pub(crate) struct FormatSuppressedNode<'a> {
-    node: AnyNodeRef<'a>,
-}
-
-impl Format<PyFormatContext<'_>> for FormatSuppressedNode<'_> {
-    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
-        let comments = f.context().comments().clone();
-        let node_comments = comments.leading_dangling_trailing(self.node);
-
-        // Mark all comments as formatted that fall into the node range
-        for comment in node_comments.leading {
-            if comment.start() > self.node.start() {
-                comment.mark_formatted();
-            }
-        }
-
-        for comment in node_comments.trailing {
-            if comment.start() < self.node.end() {
-                comment.mark_formatted();
-            }
-        }
-
-        // Some statements may end with a semicolon. Preserve the semicolon
-        let semicolon_range = self
-            .node
-            .is_statement()
-            .then(|| trailing_semicolon(self.node, f.context().source()))
-            .flatten();
-        let verbatim_range = semicolon_range.map_or(self.node.range(), |semicolon| {
-            TextRange::new(self.node.start(), semicolon.end())
-        });
-        comments.mark_verbatim_node_comments_formatted(self.node);
-
-        // Write the outer comments and format the node as verbatim
-        write!(
-            f,
-            [
-                leading_comments(node_comments.leading),
-                source_position(verbatim_range.start()),
-                verbatim_text(verbatim_range),
-                source_position(verbatim_range.end()),
-                trailing_comments(node_comments.trailing)
-            ]
-        )
-    }
-}
-
 #[cold]
 pub(crate) fn write_suppressed_clause_header(
     header: ClauseHeader,

crates/ruff_python_formatter/tests/snapshots/format@fmt_skip__semicolons.py.snap

@@ -0,0 +1,299 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+---
+## Input
+```python
+class Simple:
+    x=1
+    x=2 # fmt: skip
+    x=3
+
+class Semicolon:
+    x=1
+    x=2;x=3 # fmt: skip
+    x=4
+
+class TrailingSemicolon:
+    x=1
+    x=2;x=3    ; # fmt: skip
+    x=4
+
+class SemicolonNewLogicalLine:
+    x=1;
+    x=2;x=3 # fmt: skip
+    x=4
+
+class ManySemicolonOneLine:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class CompoundInSuite:
+    x=1
+    def foo(): y=1 # fmt: skip
+    x=2
+
+class CompoundInSuiteNewline:
+    x=1
+    def foo():
+        y=1 # fmt: skip
+    x=2
+
+class MultiLineSkip:
+    x=1
+    x = [
+        '1',
+        '2',
+    ] # fmt: skip
+
+class MultiLineSemicolon:
+    x=1
+    x = [
+        '1',
+        '2',
+    ]; x=2 # fmt: skip
+
+class LineContinuationSemicolonAfter:
+    x=1
+    x = ['a']\
+    ; y=1 # fmt: skip
+
+class LineContinuationSemicolonBefore:
+    x=1
+    x = ['a']; \
+    y=1 # fmt: skip
+
+class LineContinuationSemicolonAndNewline:
+    x=1
+    x = ['a']; \
+
+    y=1 # fmt: skip
+
+class LineContinuationSemicolonAndNewlineAndComment:
+    x=1
+    x = ['a']; \
+    # 1
+    y=1 # fmt: skip
+
+class RepeatedLineContinuation:
+    x=1
+    x = ['a']; \
+    \
+    \
+    y=1 # fmt: skip
+
+class MultiLineSemicolonComments:
+    x=1
+          # 1
+    x = [     # 2
+        '1',    # 3
+        '2',
+            # 4
+    ]; x=2    # 5   # fmt: skip    # 6
+
+class DocstringSkipped:
+    '''This is a docstring''' # fmt: skip
+    x=1
+
+class MultilineDocstringSkipped:
+    '''This is a docstring
+    ''' # fmt: skip
+    x=1
+
+class FirstStatementNewlines:
+
+
+
+
+    x=1 # fmt: skip
+
+class ChainingSemicolons:
+    x=[
+        '1',
+        '2',
+        '3',
+    ];x=1;x=[
+        '1',
+        '2',
+        '3'
+    ];x=1;x=1 # fmt: skip
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3
+        '2',
+        '3'
+    ]    ;x=2;x=3 # 4 # fmt: skip # 5
+    # 6
+
+class MixingCompound:
+    def foo(): bar(); import zoo # fmt: skip
+
+# https://github.com/astral-sh/ruff/issues/17331
+def main() -> None:
+    import ipdb; ipdb.set_trace()  # noqa: E402,E702,I001 # fmt: skip
+
+# https://github.com/astral-sh/ruff/issues/11430
+print(); print() # noqa # fmt: skip
+```
+
+## Output
+```python
+class Simple:
+    x = 1
+    x=2  # fmt: skip
+    x = 3
+
+
+class Semicolon:
+    x = 1
+    x=2;x=3  # fmt: skip
+    x = 4
+
+
+class TrailingSemicolon:
+    x = 1
+    x=2;x=3    ;  # fmt: skip
+    x = 4
+
+
+class SemicolonNewLogicalLine:
+    x = 1
+    x=2;x=3  # fmt: skip
+    x = 4
+
+
+class ManySemicolonOneLine:
+    x = 1
+    x=2;x=3;x=4  # fmt: skip
+    x = 5
+
+
+class CompoundInSuite:
+    x = 1
+
+    def foo(): y=1  # fmt: skip
+
+    x = 2
+
+
+class CompoundInSuiteNewline:
+    x = 1
+
+    def foo():
+        y=1  # fmt: skip
+
+    x = 2
+
+
+class MultiLineSkip:
+    x = 1
+    x = [
+        '1',
+        '2',
+    ]  # fmt: skip
+
+
+class MultiLineSemicolon:
+    x = 1
+    x = [
+        '1',
+        '2',
+    ]; x=2  # fmt: skip
+
+
+class LineContinuationSemicolonAfter:
+    x = 1
+    x = ['a']\
+    ; y=1  # fmt: skip
+
+
+class LineContinuationSemicolonBefore:
+    x = 1
+    x = ['a']; \
+    y=1  # fmt: skip
+
+
+class LineContinuationSemicolonAndNewline:
+    x = 1
+    x = ["a"]
+    y=1  # fmt: skip
+
+
+class LineContinuationSemicolonAndNewlineAndComment:
+    x = 1
+    x = ["a"]
+    # 1
+    y=1  # fmt: skip
+
+
+class RepeatedLineContinuation:
+    x = 1
+    x = ['a']; \
+    \
+    \
+    y=1  # fmt: skip
+
+
+class MultiLineSemicolonComments:
+    x = 1
+    # 1
+    x = [     # 2
+        '1',    # 3
+        '2',
+            # 4
+    ]; x=2  # 5   # fmt: skip    # 6
+
+
+class DocstringSkipped:
+    '''This is a docstring'''  # fmt: skip
+
+    x = 1
+
+
+class MultilineDocstringSkipped:
+    '''This is a docstring
+    '''  # fmt: skip
+
+    x = 1
+
+
+class FirstStatementNewlines:
+    x=1  # fmt: skip
+
+
+class ChainingSemicolons:
+    x=[
+        '1',
+        '2',
+        '3',
+    ];x=1;x=[
+        '1',
+        '2',
+        '3'
+    ];x=1;x=1  # fmt: skip
+
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3
+        '2',
+        '3'
+    ]    ;x=2;x=3  # 4 # fmt: skip # 5
+    # 6
+
+
+class MixingCompound:
+    def foo(): bar(); import zoo  # fmt: skip
+
+
+# https://github.com/astral-sh/ruff/issues/17331
+def main() -> None:
+    import ipdb; ipdb.set_trace()  # noqa: E402,E702,I001 # fmt: skip
+
+
+# https://github.com/astral-sh/ruff/issues/11430
+print(); print()  # noqa # fmt: skip
+```

crates/ruff_python_formatter/tests/snapshots/format@fmt_skip__top_level_semicolon.py.snap

@@ -0,0 +1,56 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+---
+## Input
+```python
+    # 0
+'''Module docstring
+multiple lines'''      # 1 # fmt: skip # 2
+
+import a;import b; from c import (
+        x,y,z
+    ); import f # fmt: skip
+
+x=1;x=2;x=3;x=4 # fmt: skip
+
+   # 1
+x=[     # 2
+    '1',       # 3
+    '2',
+    '3'
+];x=1;x=1 # 4 # fmt: skip # 5
+   # 6
+
+def foo(): x=[
+    '1',
+    '2',
+];x=1 # fmt: skip
+```
+
+## Output
+```python
+# 0
+'''Module docstring
+multiple lines'''  # 1 # fmt: skip # 2
+
+import a;import b; from c import (
+        x,y,z
+    ); import f  # fmt: skip
+
+x=1;x=2;x=3;x=4  # fmt: skip
+
+# 1
+x=[     # 2
+    '1',       # 3
+    '2',
+    '3'
+];x=1;x=1  # 4 # fmt: skip # 5
+# 6
+
+
+def foo():
+    x=[
+    '1',
+    '2',
+];x=1  # fmt: skip
+```

crates/ruff_python_formatter/tests/snapshots/format@range_formatting__fmt_skip.py.snap

@@ -0,0 +1,147 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+---
+## Input
+```python
+class Simple:
+    # Range comprises skip range
+    x=1
+    <RANGE_START>x=2 <RANGE_END># fmt: skip
+    x=3
+
+class Semicolon:
+    # Range is part of skip range
+    x=1
+    x=2;<RANGE_START>x=3<RANGE_END> # fmt: skip
+    x=4
+
+class FormatFirst:
+    x=1
+    <RANGE_START>x=2<RANGE_END>;x=3 # fmt: skip
+    x=4
+
+class FormatMiddle:
+    x=1
+    x=2;<RANGE_START>x=3<RANGE_END>;x=4 # fmt: skip
+    x=5
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on right side
+    <RANGE_START>x=1;
+    x=2<RANGE_END>;x=3 # fmt: skip
+    x=4
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on left side
+    x=1;
+    x=2;<RANGE_START>x=3 # fmt: skip
+    x=4<RANGE_END>
+
+class ManySemicolonOneLine:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class CompoundInSuite:
+    x=1
+    <RANGE_START>def foo(): y=1 <RANGE_END># fmt: skip
+    x=2
+
+class CompoundInSuiteNewline:
+    x=1
+    def foo():
+        y=1 # fmt: skip
+    x=2
+
+class MultiLineSkip:
+    # Range inside statement
+    x=1
+    x = <RANGE_START>[
+        '1',
+        '2',<RANGE_END>
+    ] # fmt: skip
+
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3<RANGE_START>
+        '2',
+        '3'
+    ]    ;x=2;x=3 # 4<RANGE_END> # fmt: skip # 5
+    # 6
+
+```
+
+## Output
+```python
+class Simple:
+    # Range comprises skip range
+    x=1
+    x=2  # fmt: skip
+    x=3
+
+class Semicolon:
+    # Range is part of skip range
+    x=1
+    x=2;x=3 # fmt: skip
+    x=4
+
+class FormatFirst:
+    x=1
+    x=2;x=3 # fmt: skip
+    x=4
+
+class FormatMiddle:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on right side
+    x = 1
+    x=2;x=3 # fmt: skip
+    x=4
+
+class SemicolonNewLogicalLine:
+    # Range overlaps on left side
+    x=1;
+    x=2;x=3  # fmt: skip
+    x = 4
+
+class ManySemicolonOneLine:
+    x=1
+    x=2;x=3;x=4 # fmt: skip
+    x=5
+
+class CompoundInSuite:
+    x=1
+    def foo(): y=1  # fmt: skip
+
+    x=2
+
+class CompoundInSuiteNewline:
+    x=1
+    def foo():
+        y=1 # fmt: skip
+    x=2
+
+class MultiLineSkip:
+    # Range inside statement
+    x=1
+    x = [
+        '1',
+        '2',
+    ] # fmt: skip
+
+
+class LotsOfComments:
+    # 1
+    x=[ # 2
+        '1', # 3
+        '2',
+        '3'
+    ]    ;x=2;x=3  # 4 # fmt: skip # 5
+    # 6
+
+```

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -406,9 +406,6 @@ reveal_type(Child.create())  # revealed: Child
 
 ## Attributes
 
-TODO: The use of `Self` to annotate the `next_node` attribute should be
-[modeled as a property][self attribute], using `Self` in its parameter and return type.
-
 ```py
 from typing import Self
 
@@ -418,13 +415,36 @@ class LinkedList:
 
     def next(self: Self) -> Self:
         reveal_type(self.value)  # revealed: int
-        # TODO: no error
-        # error: [invalid-return-type]
         return self.next_node
 
 reveal_type(LinkedList().next())  # revealed: LinkedList
 ```
 
+Dataclass fields can also use `Self` in their annotations:
+
+```py
+from dataclasses import dataclass
+from typing import Optional, Self
+
+@dataclass
+class Node:
+    parent: Optional[Self] = None
+
+Node(Node())
+```
+
+Attributes annotated with `Self` can be assigned on instances:
+
+```py
+from typing import Optional, Self
+
+class MyClass:
+    field: Optional[Self] = None
+
+def _(c: MyClass):
+    c.field = c
+```
+
 Attributes can also refer to a generic parameter:
 
 ```py
@@ -675,4 +695,73 @@ def _(c: CallableTypeOf[C().method]):
     reveal_type(c)  # revealed: (...) -> None
 ```
 
-[self attribute]: https://typing.python.org/en/latest/spec/generics.html#use-in-attribute-annotations
+## Bound methods from internal data structures stored as instance attributes
+
+This tests the pattern where a class stores bound methods from internal data structures (like
+`deque` or `dict`) as instance attributes for performance. When these bound methods are later
+accessed and called through `self`, the `Self` type binding should not interfere with their
+signatures.
+
+This is a regression test for false positives found in ecosystem projects like jinja's `LRUCache`
+and beartype's `CacheUnboundedStrong`.
+
+```py
+from collections import deque
+from typing import Any
+
+class LRUCache:
+    """A simple LRU cache that stores bound methods from an internal deque."""
+
+    def __init__(self, capacity: int) -> None:
+        self.capacity = capacity
+        self._mapping: dict[Any, Any] = {}
+        self._queue: deque[Any] = deque()
+        self._postinit()
+
+    def _postinit(self) -> None:
+        # Store bound methods from the internal deque for faster attribute lookup
+        self._popleft = self._queue.popleft
+        self._pop = self._queue.pop
+        self._remove = self._queue.remove
+        self._append = self._queue.append
+
+    def __getitem__(self, key: Any) -> Any:
+        # These should not produce errors - the bound methods have signatures
+        # from deque, not involving Self
+        self._remove(key)
+        self._append(key)
+        return self._mapping[key]
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        self._remove(key)
+        if len(self._queue) >= self.capacity:
+            self._popleft()
+        self._append(key)
+        self._mapping[key] = value
+
+    def __delitem__(self, key: Any) -> None:
+        self._remove(key)
+        del self._mapping[key]
+```
+
+Similarly for dict-based patterns:
+
+```py
+from typing import Hashable
+
+class CacheMap:
+    """A cache that stores bound methods from an internal dict."""
+
+    def __init__(self) -> None:
+        self._key_to_value: dict[Hashable, object] = {}
+        self._key_to_value_get = self._key_to_value.get
+        self._key_to_value_set = self._key_to_value.__setitem__
+
+    def cache_or_get_cached_value(self, key: Hashable, value: object) -> object:
+        # This should not produce errors - we're using dict's get/setitem methods
+        cached_value = self._key_to_value_get(key)
+        if cached_value is not None:
+            return cached_value
+        self._key_to_value_set(key, value)
+        return value
+```

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -1814,6 +1814,27 @@ def _(ns: argparse.Namespace):
     reveal_type(ns.whatever)  # revealed: Any
 ```
 
+### `__getattr__` with `Self` type
+
+`__getattr__` should also work when the receiver is typed as `Self`:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from typing import Self
+
+class CustomGetAttr:
+    def __getattr__(self, name: str) -> int:
+        return 1
+
+    def method(self) -> Self:
+        reveal_type(self.whatever)  # revealed: int
+        return self
+```
+
 ## Classes with custom `__getattribute__` methods
 
 If a type provides a custom `__getattribute__`, we use its return type as the type for unknown

crates/ty_python_semantic/resources/mdtest/diagnostics/special_form_attributes.md

@@ -21,6 +21,5 @@ X.aaaaooooooo  # error: [unresolved-attribute]
 Foo.X.startswith  # error: [unresolved-attribute]
 Foo.Bar().y.startswith  # error: [unresolved-attribute]
 
-# TODO: false positive (just testing the diagnostic in the meantime)
-Foo().b.a  # error: [unresolved-attribute]
+Foo().b.a
 ```

crates/ty_python_semantic/resources/mdtest/snapshots/special_form_attribu…_-_Diagnostics_for_inva…_(249d635e74a41c9e).snap

@@ -31,8 +31,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/diagnostics/special_form
 16 | Foo.X.startswith  # error: [unresolved-attribute]
 17 | Foo.Bar().y.startswith  # error: [unresolved-attribute]
 18 | 
-19 | # TODO: false positive (just testing the diagnostic in the meantime)
-20 | Foo().b.a  # error: [unresolved-attribute]
+19 | Foo().b.a
 ```
 
 # Diagnostics
@@ -95,21 +94,9 @@ error[unresolved-attribute]: Special form `typing.LiteralString` has no attribut
 17 | Foo.Bar().y.startswith  # error: [unresolved-attribute]
    | ^^^^^^^^^^^^^^^^^^^^^^
 18 |
-19 | # TODO: false positive (just testing the diagnostic in the meantime)
+19 | Foo().b.a
    |
 help: Objects with type `LiteralString` have a `startswith` attribute, but the symbol `typing.LiteralString` does not itself inhabit the type `LiteralString`
 info: rule `unresolved-attribute` is enabled by default
 
 ```
-
-```
-error[unresolved-attribute]: Special form `typing.Self` has no attribute `a`
-  --> src/mdtest_snippet.py:20:1
-   |
-19 | # TODO: false positive (just testing the diagnostic in the meantime)
-20 | Foo().b.a  # error: [unresolved-attribute]
-   | ^^^^^^^^^
-   |
-info: rule `unresolved-attribute` is enabled by default
-
-```

crates/ty_python_semantic/src/types.rs

@@ -2530,15 +2530,34 @@ impl<'db> Type<'db> {
             }
 
             Type::TypeVar(bound_typevar) => {
-                match bound_typevar.typevar(db).bound_or_constraints(db) {
+                let member = match bound_typevar.typevar(db).bound_or_constraints(db) {
                     None => Type::object().instance_member(db, name),
                     Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
-                        bound.instance_member(db, name)
+                        if bound_typevar.typevar(db).is_self(db) {
+                            if let Type::NominalInstance(instance) = bound {
+                                instance.class(db).instance_member(db, name)
+                            } else {
+                                bound.instance_member(db, name)
+                            }
+                        } else {
+                            bound.instance_member(db, name)
+                        }
                     }
                     Some(TypeVarBoundOrConstraints::Constraints(constraints)) => constraints
                         .map_with_boundness_and_qualifiers(db, |constraint| {
                             constraint.instance_member(db, name)
                         }),
+                };
+                if bound_typevar.typevar(db).is_self(db) {
+                    let self_mapping = TypeMapping::BindSelf {
+                        self_type: Type::TypeVar(*bound_typevar),
+                        self_typevar_identity: Some(bound_typevar.typevar(db).identity(db)),
+                    };
+                    member.map_type(|ty| {
+                        ty.apply_type_mapping(db, &self_mapping, TypeContext::default())
+                    })
+                } else {
+                    member
                 }
             }
 
@@ -3277,11 +3296,20 @@ impl<'db> Type<'db> {
             | Type::TypedDict(_) => {
                 let fallback = self.instance_member(db, name_str);
 
+                // `Self` type variables use `InstanceFallbackShadowsNonDataDescriptor::Yes`
+                // because instance attributes should shadow non-data descriptors on the class.
+                let instance_fallback_shadows = if matches!(self, Type::TypeVar(tv) if tv.typevar(db).is_self(db))
+                {
+                    InstanceFallbackShadowsNonDataDescriptor::Yes
+                } else {
+                    InstanceFallbackShadowsNonDataDescriptor::No
+                };
+
                 let result = self.invoke_descriptor_protocol(
                     db,
                     name_str,
                     fallback,
-                    InstanceFallbackShadowsNonDataDescriptor::No,
+                    instance_fallback_shadows,
                     policy,
                 );
 
@@ -6867,7 +6895,8 @@ pub enum TypeMapping<'a, 'db> {
     /// Binds any `typing.Self` typevar with a particular `self` class.
     BindSelf {
         self_type: Type<'db>,
-        binding_context: Option<BindingContext<'db>>,
+        /// If `Some`, only bind `Self` typevars that have this identity (i.e., from the same class).
+        self_typevar_identity: Option<TypeVarIdentity<'db>>,
     },
     /// Replaces occurrences of `typing.Self` with a new `Self` type variable with the given upper bound.
     ReplaceSelf { new_upper_bound: Type<'db> },
@@ -6897,8 +6926,9 @@ impl<'db> TypeMapping<'_, 'db> {
             | TypeMapping::ReplaceParameterDefaults
             | TypeMapping::EagerExpansion => context,
             TypeMapping::BindSelf {
-                binding_context, ..
-            } => context.remove_self(db, *binding_context),
+                self_typevar_identity,
+                ..
+            } => context.remove_self(db, *self_typevar_identity),
             TypeMapping::ReplaceSelf { new_upper_bound } => GenericContext::from_typevar_instances(
                 db,
                 context.variables(db).map(|typevar| {
@@ -8533,10 +8563,11 @@ impl<'db> BoundTypeVarInstance<'db> {
             }
             TypeMapping::BindSelf {
                 self_type,
-                binding_context,
+                self_typevar_identity,
             } => {
                 if self.typevar(db).is_self(db)
-                    && binding_context.is_none_or(|context| self.binding_context(db) == context)
+                    && self_typevar_identity
+                        .is_none_or(|identity| self.typevar(db).identity(db) == identity)
                 {
                     *self_type
                 } else {

crates/ty_python_semantic/src/types/generics.rs

@@ -23,8 +23,8 @@ use crate::types::tuple::{TupleSpec, TupleType, walk_tuple_type};
 use crate::types::variance::VarianceInferable;
 use crate::types::visitor::{TypeCollector, TypeVisitor, walk_type_with_recursion_guard};
 use crate::types::{
-    ApplyTypeMappingVisitor, BindingContext, BoundTypeVarIdentity, BoundTypeVarInstance,
-    ClassLiteral, FindLegacyTypeVarsVisitor, IntersectionType, KnownClass, KnownInstanceType,
+    ApplyTypeMappingVisitor, BoundTypeVarIdentity, BoundTypeVarInstance, ClassLiteral,
+    FindLegacyTypeVarsVisitor, IntersectionType, KnownClass, KnownInstanceType,
     MaterializationKind, NormalizedVisitor, Type, TypeContext, TypeMapping,
     TypeVarBoundOrConstraints, TypeVarIdentity, TypeVarInstance, TypeVarKind, TypeVarVariance,
     UnionType, declaration_type, walk_type_var_bounds,
@@ -66,12 +66,26 @@ pub(crate) fn bind_typevar<'db>(
 ) -> Option<BoundTypeVarInstance<'db>> {
     // typing.Self is treated like a legacy typevar, but doesn't follow the same scoping rules. It is always bound to the outermost method in the containing class.
     if matches!(typevar.kind(db), TypeVarKind::TypingSelf) {
-        for ((_, inner), (_, outer)) in index.ancestor_scopes(containing_scope).tuple_windows() {
-            if outer.kind().is_class() {
-                if let NodeWithScopeKind::Function(function) = inner.node() {
-                    let definition = index.expect_single_definition(function);
+        let binding_function =
+            typevar_binding_context.filter(|definition| definition.kind(db).is_function_def());
+        let mut function_in_class = None;
+        for (_, scope) in index.ancestor_scopes(containing_scope) {
+            match scope.node() {
+                NodeWithScopeKind::Function(function) => {
+                    function_in_class = Some(function);
+                }
+                NodeWithScopeKind::Class(class) => {
+                    if let Some(function) = function_in_class {
+                        let definition = index.expect_single_definition(function);
+                        return Some(typevar.with_binding_context(db, definition));
+                    }
+                    if let Some(binding_context) = binding_function {
+                        return Some(typevar.with_binding_context(db, binding_context));
+                    }
+                    let definition = index.expect_single_definition(class);
                     return Some(typevar.with_binding_context(db, definition));
                 }
+                _ => {}
             }
         }
     }
@@ -281,15 +295,14 @@ impl<'db> GenericContext<'db> {
     pub(crate) fn remove_self(
         self,
         db: &'db dyn Db,
-        binding_context: Option<BindingContext<'db>>,
+        self_typevar_identity: Option<TypeVarIdentity<'db>>,
     ) -> Self {
         Self::from_typevar_instances(
             db,
             self.variables(db).filter(|bound_typevar| {
                 !(bound_typevar.typevar(db).is_self(db)
-                    && binding_context.is_none_or(|binding_context| {
-                        bound_typevar.binding_context(db) == binding_context
-                    }))
+                    && self_typevar_identity
+                        .is_none_or(|identity| bound_typevar.typevar(db).identity(db) == identity))
             }),
         )
     }

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -112,10 +112,10 @@ use crate::types::{
     LintDiagnosticGuard, MemberLookupPolicy, MetaclassCandidate, PEP695TypeAliasType,
     ParamSpecAttrKind, Parameter, ParameterForm, Parameters, Signature, SpecialFormType,
     SubclassOfType, TrackedConstraintSet, Truthiness, Type, TypeAliasType, TypeAndQualifiers,
-    TypeContext, TypeQualifiers, TypeVarBoundOrConstraints, TypeVarBoundOrConstraintsEvaluation,
-    TypeVarDefaultEvaluation, TypeVarIdentity, TypeVarInstance, TypeVarKind, TypeVarVariance,
-    TypedDictType, UnionBuilder, UnionType, UnionTypeInstance, binding_type, infer_scope_types,
-    todo_type,
+    TypeContext, TypeMapping, TypeQualifiers, TypeVarBoundOrConstraints,
+    TypeVarBoundOrConstraintsEvaluation, TypeVarDefaultEvaluation, TypeVarIdentity,
+    TypeVarInstance, TypeVarKind, TypeVarVariance, TypedDictType, UnionBuilder, UnionType,
+    UnionTypeInstance, binding_type, infer_scope_types, todo_type,
 };
 use crate::types::{CallableTypes, overrides};
 use crate::types::{ClassBase, add_inferred_python_version_hint_to_diagnostic};
@@ -4530,6 +4530,12 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         let db = self.db();
 
         let mut first_tcx = None;
+        let self_mapping = TypeMapping::BindSelf {
+            self_type: object_ty,
+            self_typevar_identity: None,
+        };
+        let bind_self =
+            |ty: Type<'db>| ty.apply_type_mapping(db, &self_mapping, TypeContext::default());
 
         // A wrapper over `infer_value_ty` that allows inferring the value type multiple times
         // during attribute resolution.
@@ -4877,6 +4883,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             }),
                         qualifiers,
                     } => {
+                        let meta_attr_ty = bind_self(meta_attr_ty);
                         if invalid_assignment_to_final(self, qualifiers) {
                             return false;
                         }
@@ -4928,6 +4935,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             } =
                                 object_ty.instance_member(db, attribute)
                             {
+                                let instance_attr_ty = bind_self(instance_attr_ty);
                                 let value_ty =
                                     infer_value_ty(self, TypeContext::new(Some(instance_attr_ty)));
                                 if invalid_assignment_to_final(self, qualifiers) {
@@ -4973,6 +4981,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             qualifiers,
                         } = object_ty.instance_member(db, attribute)
                         {
+                            let instance_attr_ty = bind_self(instance_attr_ty);
                             let value_ty =
                                 infer_value_ty(self, TypeContext::new(Some(instance_attr_ty)));
                             if invalid_assignment_to_final(self, qualifiers) {

crates/ty_python_semantic/src/types/signatures.rs

@@ -25,7 +25,7 @@ use crate::types::relation::{
     HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, TypeRelation,
 };
 use crate::types::{
-    ApplyTypeMappingVisitor, BindingContext, BoundTypeVarInstance, CallableType, CallableTypeKind,
+    ApplyTypeMappingVisitor, BoundTypeVarInstance, CallableType, CallableTypeKind,
     FindLegacyTypeVarsVisitor, KnownClass, MaterializationKind, NormalizedVisitor,
     ParamSpecAttrKind, TypeContext, TypeMapping, VarianceInferable, todo_type,
 };
@@ -893,13 +893,21 @@ impl<'db> Signature<'db> {
             parameters.next();
         }
 
+        // Find the Self typevar from this signature's generic context, if any.
+        // We only want to bind Self typevars that belong to this signature, not
+        // Self typevars from other classes that might appear in type parameters.
+        let self_typevar_identity = self.generic_context.and_then(|ctx| {
+            ctx.variables(db)
+                .find(|tv| tv.typevar(db).is_self(db))
+                .map(|tv| tv.typevar(db).identity(db))
+        });
+
         let mut parameters = Parameters::new(db, parameters);
         let mut return_ty = self.return_ty;
-        let binding_context = self.definition.map(BindingContext::Definition);
         if let Some(self_type) = self_type {
             let self_mapping = TypeMapping::BindSelf {
                 self_type,
-                binding_context,
+                self_typevar_identity,
             };
             parameters = parameters.apply_type_mapping_impl(
                 db,
@@ -912,7 +920,7 @@ impl<'db> Signature<'db> {
         Self {
             generic_context: self
                 .generic_context
-                .map(|generic_context| generic_context.remove_self(db, binding_context)),
+                .map(|generic_context| generic_context.remove_self(db, self_typevar_identity)),
             definition: self.definition,
             parameters,
             return_ty,
@@ -920,9 +928,15 @@ impl<'db> Signature<'db> {
     }
 
     pub(crate) fn apply_self(&self, db: &'db dyn Db, self_type: Type<'db>) -> Self {
+        // Find the Self typevar from this signature's generic context, if any.
+        let self_typevar_identity = self.generic_context.and_then(|ctx| {
+            ctx.variables(db)
+                .find(|tv| tv.typevar(db).is_self(db))
+                .map(|tv| tv.typevar(db).identity(db))
+        });
         let self_mapping = TypeMapping::BindSelf {
             self_type,
-            binding_context: self.definition.map(BindingContext::Definition),
+            self_typevar_identity,
         };
         let parameters = self.parameters.apply_type_mapping_impl(
             db,

docs/formatter.md

@@ -265,26 +265,29 @@ Instead, apply the `# fmt: off` comment to the entire statement:
 Like Black, Ruff will _also_ recognize [YAPF](https://github.com/google/yapf)'s `# yapf: disable` and `# yapf: enable` pragma
 comments, which are treated equivalently to `# fmt: off` and `# fmt: on`, respectively.
 
-`# fmt: skip` comments suppress formatting for a preceding statement, case header, decorator,
-function definition, or class definition:
+`# fmt: skip` comments suppress formatting for a case header, decorator,
+function definition, class definition, or the preceding statements
+on the same logical line. The formatter leaves the following unchanged:
 
 ```python
 if True:
     pass
-elif False: # fmt: skip
+elif     False: # fmt: skip
     pass
 
 @Test
-@Test2 # fmt: skip
+@Test2(a,b) # fmt: skip
 def test(): ...
 
-a = [1, 2, 3, 4, 5] # fmt: skip
+a = [1,2,3,4,5] # fmt: skip
 
-def test(a, b, c, d, e, f) -> int: # fmt: skip
+def test(a,b,c,d,e,f) -> int: # fmt: skip
     pass
+
+x=1;x=2;x=3 # fmt: skip
 ```
 
-As such, adding an `# fmt: skip` comment at the end of an expression will have no effect. In
+Adding a `# fmt: skip` comment at the end of an expression will have no effect. In
 the following example, the list entry `'1'` will be formatted, despite the `# fmt: skip`:
 
 ```python