Use one line between top-level items if formatting a stub file

crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/top_level.py

@@ -0,0 +1,25 @@
+class A:
+    def __init__(self):
+        pass
+
+class B:
+    def __init__(self):
+        pass
+
+def foo():
+    pass
+
+class Del(expr_context): ...
+class Load(expr_context): ...
+class Store(expr_context): ...
+
+class Foo(Bar):
+    ...
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+class Quux(Qux):
+    def __init__(self):
+        pass

crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/top_level.pyi

@@ -0,0 +1,38 @@
+class A:
+    def __init__(self):
+        pass
+
+
+class B:
+    def __init__(self):
+        pass
+
+
+def foo():
+    pass
+
+
+class Del(expr_context):
+    ...
+
+
+class Load(expr_context):
+    ...
+
+
+class Store(expr_context):
+    ...
+
+
+class Foo(Bar):
+    ...
+
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+
+class Quux(Qux):
+    def __init__(self):
+        pass

crates/ruff_python_formatter/src/options.rs

@@ -72,6 +72,10 @@ impl PyFormatOptions {
         self.quote_style
     }
 
+    pub fn source_type(&self) -> PySourceType {
+        self.source_type
+    }
+
     #[must_use]
     pub fn with_quote_style(mut self, style: QuoteStyle) -> Self {
         self.quote_style = style;

crates/ruff_python_formatter/src/statement/suite.rs

@@ -46,6 +46,7 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
 
         let comments = f.context().comments().clone();
         let source = f.context().source();
+        let source_type = f.options().source_type();
 
         let mut iter = statements.iter();
         let Some(first) = iter.next() else {
@@ -116,6 +117,38 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
         for statement in iter {
             if is_class_or_function_definition(last) || is_class_or_function_definition(statement) {
                 match self.kind {
+                    SuiteKind::TopLevel if source_type.is_stub() => match (last, statement) {
+                        // Check if the statements are class definitions of the
+                        // same type, containing only an ellipsis.
+                        (
+                            Stmt::ClassDef(ast::StmtClassDef {
+                                arguments: Some(last_args),
+                                body: last_body,
+                                ..
+                            }),
+                            Stmt::ClassDef(ast::StmtClassDef {
+                                arguments: Some(args),
+                                body,
+                                ..
+                            }),
+                        ) if last_args.len() == args.len()
+                            && last_args.args.iter().zip(args.args.iter()).all(
+                                |(last_arg, arg)| match (last_arg, arg) {
+                                    (Expr::Name(last_name), Expr::Name(name)) => {
+                                        last_name.id == name.id
+                                    }
+                                    _ => false,
+                                },
+                            )
+                            && contains_only_an_ellipsis(last_body)
+                            && contains_only_an_ellipsis(body) =>
+                        {
+                            write!(f, [statement.format()])?;
+                        }
+                        // Otherwise, top-level stub items should be separated
+                        // one empty line.
+                        _ => write!(f, [empty_line(), statement.format()])?,
+                    },
                     SuiteKind::TopLevel => {
                         write!(f, [empty_line(), empty_line(), statement.format()])?;
                     }
@@ -208,6 +241,23 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
     }
 }
 
+/// Returns `true` if a function or class body contains only an ellipsis.
+fn contains_only_an_ellipsis(body: &Vec<Stmt>) -> bool {
+    body.len() == 1
+        && body.first().map_or(false, |stmt| match stmt {
+            Stmt::Expr(ast::StmtExpr { value, .. }) => {
+                matches!(
+                    value.as_ref(),
+                    Expr::Constant(ast::ExprConstant {
+                        value: Constant::Ellipsis,
+                        ..
+                    })
+                )
+            }
+            _ => false,
+        })
+}
+
 /// Returns `true` if a [`Stmt`] is a class or function definition.
 const fn is_class_or_function_definition(stmt: &Stmt) -> bool {
     matches!(stmt, Stmt::FunctionDef(_) | Stmt::ClassDef(_))

crates/ruff_python_formatter/tests/fixtures.rs

@@ -161,7 +161,7 @@ fn format() {
         });
     };
 
-    insta::glob!("../resources", "test/fixtures/ruff/**/*.py", test_file);
+    insta::glob!("../resources", "test/fixtures/ruff/**/*.py*", test_file);
 }
 
 /// Format another time and make sure that there are no changes anymore

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

@@ -0,0 +1,77 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+input_file: crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/top_level.py
+---
+## Input
+```py
+class A:
+    def __init__(self):
+        pass
+
+class B:
+    def __init__(self):
+        pass
+
+def foo():
+    pass
+
+class Del(expr_context): ...
+class Load(expr_context): ...
+class Store(expr_context): ...
+
+class Foo(Bar):
+    ...
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+class Quux(Qux):
+    def __init__(self):
+        pass
+```
+
+## Output
+```py
+class A:
+    def __init__(self):
+        pass
+
+
+class B:
+    def __init__(self):
+        pass
+
+
+def foo():
+    pass
+
+
+class Del(expr_context):
+    ...
+
+
+class Load(expr_context):
+    ...
+
+
+class Store(expr_context):
+    ...
+
+
+class Foo(Bar):
+    ...
+
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+
+class Quux(Qux):
+    def __init__(self):
+        pass
+```
+
+
+

crates/ruff_python_formatter/tests/snapshots/format@statement__top_level.pyi.snap

@@ -0,0 +1,80 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+input_file: crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/top_level.pyi
+---
+## Input
+```py
+class A:
+    def __init__(self):
+        pass
+
+
+class B:
+    def __init__(self):
+        pass
+
+
+def foo():
+    pass
+
+
+class Del(expr_context):
+    ...
+
+
+class Load(expr_context):
+    ...
+
+
+class Store(expr_context):
+    ...
+
+
+class Foo(Bar):
+    ...
+
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+
+class Quux(Qux):
+    def __init__(self):
+        pass
+```
+
+## Output
+```py
+class A:
+    def __init__(self):
+        pass
+
+class B:
+    def __init__(self):
+        pass
+
+def foo():
+    pass
+
+class Del(expr_context):
+    ...
+class Load(expr_context):
+    ...
+class Store(expr_context):
+    ...
+
+class Foo(Bar):
+    ...
+
+class Baz(Qux):
+    def __init__(self):
+        pass
+
+class Quux(Qux):
+    def __init__(self):
+        pass
+```
+
+
+