Generate FormatRule definitions (#4724)

* Generate FormatRule definitions

* Generate verbatim output

* pub(crate) everything

* clippy fix

* Update crates/ruff_python_formatter/src/lib.rs

Co-authored-by: Micha Reiser <micha@reiser.io>

* Update crates/ruff_python_formatter/src/lib.rs

Co-authored-by: Micha Reiser <micha@reiser.io>

* stub out with Ok(()) again

* Update crates/ruff_python_formatter/src/lib.rs

Co-authored-by: Micha Reiser <micha@reiser.io>

* PyFormatContext::{contents, locator} with `#[allow(unused)]`

* Can't leak private type

* remove commented code

* Fix ruff errors

* pub struct Format{node} due to rust rules

---------

Co-authored-by: Julian LaNeve <lanevejulian@gmail.com>
Co-authored-by: Micha Reiser <micha@reiser.io>

crates/ruff_python_formatter/src/context.rs

@@ -4,13 +4,13 @@ use ruff_python_ast::source_code::Locator;
 use std::fmt::{Debug, Formatter};
 
 #[derive(Clone)]
-pub struct ASTFormatContext<'a> {
+pub struct PyFormatContext<'a> {
     options: SimpleFormatOptions,
     contents: &'a str,
     comments: Comments<'a>,
 }
 
-impl<'a> ASTFormatContext<'a> {
+impl<'a> PyFormatContext<'a> {
     pub(crate) fn new(
         options: SimpleFormatOptions,
         contents: &'a str,
@@ -23,11 +23,13 @@ impl<'a> ASTFormatContext<'a> {
         }
     }
 
-    pub fn contents(&self) -> &'a str {
+    #[allow(unused)]
+    pub(crate) fn contents(&self) -> &'a str {
         self.contents
     }
 
-    pub fn locator(&self) -> Locator<'a> {
+    #[allow(unused)]
+    pub(crate) fn locator(&self) -> Locator<'a> {
         Locator::new(self.contents)
     }
 
@@ -37,7 +39,7 @@ impl<'a> ASTFormatContext<'a> {
     }
 }
 
-impl FormatContext for ASTFormatContext<'_> {
+impl FormatContext for PyFormatContext<'_> {
     type Options = SimpleFormatOptions;
 
     fn options(&self) -> &Self::Options {
@@ -49,9 +51,9 @@ impl FormatContext for ASTFormatContext<'_> {
     }
 }
 
-impl Debug for ASTFormatContext<'_> {
+impl Debug for PyFormatContext<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ASTFormatContext")
+        f.debug_struct("PyFormatContext")
             .field("options", &self.options)
             .field("comments", &self.comments.debug(self.source_code()))
             .field("source", &self.contents)

crates/ruff_python_formatter/src/expression/expr_attribute.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprAttribute;
+
+#[derive(Default)]
+pub struct FormatExprAttribute;
+
+impl FormatNodeRule<ExprAttribute> for FormatExprAttribute {
+    fn fmt_fields(&self, _item: &ExprAttribute, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_await.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprAwait;
+
+#[derive(Default)]
+pub struct FormatExprAwait;
+
+impl FormatNodeRule<ExprAwait> for FormatExprAwait {
+    fn fmt_fields(&self, _item: &ExprAwait, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_bin_op.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprBinOp;
+
+#[derive(Default)]
+pub struct FormatExprBinOp;
+
+impl FormatNodeRule<ExprBinOp> for FormatExprBinOp {
+    fn fmt_fields(&self, _item: &ExprBinOp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_bool_op.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprBoolOp;
+
+#[derive(Default)]
+pub struct FormatExprBoolOp;
+
+impl FormatNodeRule<ExprBoolOp> for FormatExprBoolOp {
+    fn fmt_fields(&self, _item: &ExprBoolOp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_call.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprCall;
+
+#[derive(Default)]
+pub struct FormatExprCall;
+
+impl FormatNodeRule<ExprCall> for FormatExprCall {
+    fn fmt_fields(&self, _item: &ExprCall, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_compare.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprCompare;
+
+#[derive(Default)]
+pub struct FormatExprCompare;
+
+impl FormatNodeRule<ExprCompare> for FormatExprCompare {
+    fn fmt_fields(&self, _item: &ExprCompare, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_constant.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprConstant;
+
+#[derive(Default)]
+pub struct FormatExprConstant;
+
+impl FormatNodeRule<ExprConstant> for FormatExprConstant {
+    fn fmt_fields(&self, _item: &ExprConstant, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_dict.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprDict;
+
+#[derive(Default)]
+pub struct FormatExprDict;
+
+impl FormatNodeRule<ExprDict> for FormatExprDict {
+    fn fmt_fields(&self, _item: &ExprDict, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_dict_comp.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprDictComp;
+
+#[derive(Default)]
+pub struct FormatExprDictComp;
+
+impl FormatNodeRule<ExprDictComp> for FormatExprDictComp {
+    fn fmt_fields(&self, _item: &ExprDictComp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_formatted_value.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprFormattedValue;
+
+#[derive(Default)]
+pub struct FormatExprFormattedValue;
+
+impl FormatNodeRule<ExprFormattedValue> for FormatExprFormattedValue {
+    fn fmt_fields(&self, _item: &ExprFormattedValue, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_generator_exp.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprGeneratorExp;
+
+#[derive(Default)]
+pub struct FormatExprGeneratorExp;
+
+impl FormatNodeRule<ExprGeneratorExp> for FormatExprGeneratorExp {
+    fn fmt_fields(&self, _item: &ExprGeneratorExp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_if_exp.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprIfExp;
+
+#[derive(Default)]
+pub struct FormatExprIfExp;
+
+impl FormatNodeRule<ExprIfExp> for FormatExprIfExp {
+    fn fmt_fields(&self, _item: &ExprIfExp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_joined_str.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprJoinedStr;
+
+#[derive(Default)]
+pub struct FormatExprJoinedStr;
+
+impl FormatNodeRule<ExprJoinedStr> for FormatExprJoinedStr {
+    fn fmt_fields(&self, _item: &ExprJoinedStr, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_lambda.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprLambda;
+
+#[derive(Default)]
+pub struct FormatExprLambda;
+
+impl FormatNodeRule<ExprLambda> for FormatExprLambda {
+    fn fmt_fields(&self, _item: &ExprLambda, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_list.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprList;
+
+#[derive(Default)]
+pub struct FormatExprList;
+
+impl FormatNodeRule<ExprList> for FormatExprList {
+    fn fmt_fields(&self, _item: &ExprList, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_list_comp.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprListComp;
+
+#[derive(Default)]
+pub struct FormatExprListComp;
+
+impl FormatNodeRule<ExprListComp> for FormatExprListComp {
+    fn fmt_fields(&self, _item: &ExprListComp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_name.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprName;
+
+#[derive(Default)]
+pub struct FormatExprName;
+
+impl FormatNodeRule<ExprName> for FormatExprName {
+    fn fmt_fields(&self, _item: &ExprName, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_named_expr.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprNamedExpr;
+
+#[derive(Default)]
+pub struct FormatExprNamedExpr;
+
+impl FormatNodeRule<ExprNamedExpr> for FormatExprNamedExpr {
+    fn fmt_fields(&self, _item: &ExprNamedExpr, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_set.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprSet;
+
+#[derive(Default)]
+pub struct FormatExprSet;
+
+impl FormatNodeRule<ExprSet> for FormatExprSet {
+    fn fmt_fields(&self, _item: &ExprSet, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_set_comp.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprSetComp;
+
+#[derive(Default)]
+pub struct FormatExprSetComp;
+
+impl FormatNodeRule<ExprSetComp> for FormatExprSetComp {
+    fn fmt_fields(&self, _item: &ExprSetComp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_slice.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprSlice;
+
+#[derive(Default)]
+pub struct FormatExprSlice;
+
+impl FormatNodeRule<ExprSlice> for FormatExprSlice {
+    fn fmt_fields(&self, _item: &ExprSlice, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_starred.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprStarred;
+
+#[derive(Default)]
+pub struct FormatExprStarred;
+
+impl FormatNodeRule<ExprStarred> for FormatExprStarred {
+    fn fmt_fields(&self, _item: &ExprStarred, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_subscript.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprSubscript;
+
+#[derive(Default)]
+pub struct FormatExprSubscript;
+
+impl FormatNodeRule<ExprSubscript> for FormatExprSubscript {
+    fn fmt_fields(&self, _item: &ExprSubscript, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_tuple.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprTuple;
+
+#[derive(Default)]
+pub struct FormatExprTuple;
+
+impl FormatNodeRule<ExprTuple> for FormatExprTuple {
+    fn fmt_fields(&self, _item: &ExprTuple, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_unary_op.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprUnaryOp;
+
+#[derive(Default)]
+pub struct FormatExprUnaryOp;
+
+impl FormatNodeRule<ExprUnaryOp> for FormatExprUnaryOp {
+    fn fmt_fields(&self, _item: &ExprUnaryOp, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_yield.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprYield;
+
+#[derive(Default)]
+pub struct FormatExprYield;
+
+impl FormatNodeRule<ExprYield> for FormatExprYield {
+    fn fmt_fields(&self, _item: &ExprYield, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/expr_yield_from.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExprYieldFrom;
+
+#[derive(Default)]
+pub struct FormatExprYieldFrom;
+
+impl FormatNodeRule<ExprYieldFrom> for FormatExprYieldFrom {
+    fn fmt_fields(&self, _item: &ExprYieldFrom, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/expression/mod.rs

@@ -0,0 +1,27 @@
+pub(crate) mod expr_attribute;
+pub(crate) mod expr_await;
+pub(crate) mod expr_bin_op;
+pub(crate) mod expr_bool_op;
+pub(crate) mod expr_call;
+pub(crate) mod expr_compare;
+pub(crate) mod expr_constant;
+pub(crate) mod expr_dict;
+pub(crate) mod expr_dict_comp;
+pub(crate) mod expr_formatted_value;
+pub(crate) mod expr_generator_exp;
+pub(crate) mod expr_if_exp;
+pub(crate) mod expr_joined_str;
+pub(crate) mod expr_lambda;
+pub(crate) mod expr_list;
+pub(crate) mod expr_list_comp;
+pub(crate) mod expr_name;
+pub(crate) mod expr_named_expr;
+pub(crate) mod expr_set;
+pub(crate) mod expr_set_comp;
+pub(crate) mod expr_slice;
+pub(crate) mod expr_starred;
+pub(crate) mod expr_subscript;
+pub(crate) mod expr_tuple;
+pub(crate) mod expr_unary_op;
+pub(crate) mod expr_yield;
+pub(crate) mod expr_yield_from;

crates/ruff_python_formatter/src/lib.rs

@@ -3,23 +3,86 @@ use rustpython_parser::ast::Mod;
 use rustpython_parser::lexer::lex;
 use rustpython_parser::{parse_tokens, Mode};
 
+use ruff_formatter::formatter::Formatter;
+use ruff_formatter::prelude::source_position;
 use ruff_formatter::{
-    format, FormatResult, Formatted, IndentStyle, Printed, SimpleFormatOptions, SourceCode,
+    format, write, Buffer, FormatResult, Formatted, IndentStyle, Printed, SimpleFormatOptions,
+    SourceCode,
 };
+use ruff_python_ast::node::AstNode;
 use ruff_python_ast::source_code::{CommentRanges, CommentRangesBuilder, Locator};
 
 use crate::comments::Comments;
-use crate::context::ASTFormatContext;
+use crate::context::PyFormatContext;
 use crate::module::FormatModule;
 
 pub mod cli;
 mod comments;
-pub mod context;
-mod module;
+pub(crate) mod context;
+pub(crate) mod expression;
+mod generated;
+pub(crate) mod module;
+pub(crate) mod other;
+pub(crate) mod pattern;
 mod prelude;
+pub(crate) mod statement;
 
 include!("../../ruff_formatter/shared_traits.rs");
 
+pub(crate) type PyFormatter<'buf, 'ast> = Formatter<'buf, PyFormatContext<'ast>>;
+
+/// Rule for formatting a JavaScript [`AstNode`].
+pub(crate) trait FormatNodeRule<N>
+where
+    N: AstNode,
+{
+    fn fmt(&self, node: &N, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [source_position(node.start())])?;
+        self.fmt_leading_comments(node, f)?;
+        self.fmt_node(node, f)?;
+        self.fmt_dangling_comments(node, f)?;
+        self.fmt_trailing_comments(node, f)?;
+        write!(f, [source_position(node.start())])
+    }
+
+    /// Formats the node without comments. Ignores any suppression comments.
+    fn fmt_node(&self, node: &N, f: &mut PyFormatter) -> FormatResult<()> {
+        self.fmt_fields(node, f)?;
+
+        Ok(())
+    }
+
+    /// Formats the node's fields.
+    fn fmt_fields(&self, item: &N, f: &mut PyFormatter) -> FormatResult<()>;
+
+    /// Formats the [leading comments](crate::comments#leading-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the leading comments.
+    fn fmt_leading_comments(&self, _node: &N, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+
+    /// Formats the [dangling comments](rome_formatter::comments#dangling-comments) of the node.
+    ///
+    /// You should override this method if the node handled by this rule can have dangling comments because the
+    /// default implementation formats the dangling comments at the end of the node, which isn't ideal but ensures that
+    /// no comments are dropped.
+    ///
+    /// A node can have dangling comments if all its children are tokens or if all node childrens are optional.
+    fn fmt_dangling_comments(&self, _node: &N, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+
+    /// Formats the [trailing comments](rome_formatter::comments#trailing-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the trailing comments.
+    fn fmt_trailing_comments(&self, _node: &N, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}
+
 pub fn format_module(contents: &str) -> Result<Printed> {
     // Tokenize once
     let mut tokens = Vec::new();
@@ -52,13 +115,13 @@ pub fn format_node<'a>(
     root: &'a Mod,
     comment_ranges: &'a CommentRanges,
     source: &'a str,
-) -> FormatResult<Formatted<ASTFormatContext<'a>>> {
+) -> FormatResult<Formatted<PyFormatContext<'a>>> {
     let comments = Comments::from_ast(root, SourceCode::new(source), comment_ranges);
 
     let locator = Locator::new(source);
 
     format!(
-        ASTFormatContext::new(
+        PyFormatContext::new(
             SimpleFormatOptions {
                 indent_style: IndentStyle::Space(4),
                 line_width: 88.try_into().unwrap(),

crates/ruff_python_formatter/src/module/mod.rs

@@ -1,4 +1,9 @@
-use crate::context::ASTFormatContext;
+pub(crate) mod mod_expression;
+pub(crate) mod mod_function_type;
+pub(crate) mod mod_interactive;
+pub(crate) mod mod_module;
+
+use crate::context::PyFormatContext;
 use ruff_formatter::format_element::tag::VerbatimKind;
 use ruff_formatter::prelude::*;
 use ruff_formatter::write;
@@ -14,8 +19,8 @@ impl<'a> FormatModule<'a> {
     }
 }
 
-impl Format<ASTFormatContext<'_>> for FormatModule<'_> {
-    fn fmt(&self, f: &mut Formatter<ASTFormatContext<'_>>) -> FormatResult<()> {
+impl Format<PyFormatContext<'_>> for FormatModule<'_> {
+    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
         let range = self.module.range();
 
         write!(f, [source_position(range.start())])?;

crates/ruff_python_formatter/src/module/mod_expression.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ModExpression;
+
+#[derive(Default)]
+pub struct FormatModExpression;
+
+impl FormatNodeRule<ModExpression> for FormatModExpression {
+    fn fmt_fields(&self, _item: &ModExpression, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/module/mod_function_type.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ModFunctionType;
+
+#[derive(Default)]
+pub struct FormatModFunctionType;
+
+impl FormatNodeRule<ModFunctionType> for FormatModFunctionType {
+    fn fmt_fields(&self, _item: &ModFunctionType, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/module/mod_interactive.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ModInteractive;
+
+#[derive(Default)]
+pub struct FormatModInteractive;
+
+impl FormatNodeRule<ModInteractive> for FormatModInteractive {
+    fn fmt_fields(&self, _item: &ModInteractive, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/module/mod_module.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ModModule;
+
+#[derive(Default)]
+pub struct FormatModModule;
+
+impl FormatNodeRule<ModModule> for FormatModModule {
+    fn fmt_fields(&self, _item: &ModModule, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/alias.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Alias;
+
+#[derive(Default)]
+pub struct FormatAlias;
+
+impl FormatNodeRule<Alias> for FormatAlias {
+    fn fmt_fields(&self, _item: &Alias, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/arg.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Arg;
+
+#[derive(Default)]
+pub struct FormatArg;
+
+impl FormatNodeRule<Arg> for FormatArg {
+    fn fmt_fields(&self, _item: &Arg, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/arguments.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Arguments;
+
+#[derive(Default)]
+pub struct FormatArguments;
+
+impl FormatNodeRule<Arguments> for FormatArguments {
+    fn fmt_fields(&self, _item: &Arguments, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/comprehension.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Comprehension;
+
+#[derive(Default)]
+pub struct FormatComprehension;
+
+impl FormatNodeRule<Comprehension> for FormatComprehension {
+    fn fmt_fields(&self, _item: &Comprehension, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/excepthandler_except_handler.rs

@@ -0,0 +1,16 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::ExcepthandlerExceptHandler;
+
+#[derive(Default)]
+pub struct FormatExcepthandlerExceptHandler;
+
+impl FormatNodeRule<ExcepthandlerExceptHandler> for FormatExcepthandlerExceptHandler {
+    fn fmt_fields(
+        &self,
+        _item: &ExcepthandlerExceptHandler,
+        _f: &mut PyFormatter,
+    ) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/keyword.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Keyword;
+
+#[derive(Default)]
+pub struct FormatKeyword;
+
+impl FormatNodeRule<Keyword> for FormatKeyword {
+    fn fmt_fields(&self, _item: &Keyword, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/match_case.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::MatchCase;
+
+#[derive(Default)]
+pub struct FormatMatchCase;
+
+impl FormatNodeRule<MatchCase> for FormatMatchCase {
+    fn fmt_fields(&self, _item: &MatchCase, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/mod.rs

@@ -0,0 +1,9 @@
+pub(crate) mod alias;
+pub(crate) mod arg;
+pub(crate) mod arguments;
+pub(crate) mod comprehension;
+pub(crate) mod excepthandler_except_handler;
+pub(crate) mod keyword;
+pub(crate) mod match_case;
+pub(crate) mod type_ignore_type_ignore;
+pub(crate) mod withitem;

crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::TypeIgnoreTypeIgnore;
+
+#[derive(Default)]
+pub struct FormatTypeIgnoreTypeIgnore;
+
+impl FormatNodeRule<TypeIgnoreTypeIgnore> for FormatTypeIgnoreTypeIgnore {
+    fn fmt_fields(&self, _item: &TypeIgnoreTypeIgnore, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/other/withitem.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::Withitem;
+
+#[derive(Default)]
+pub struct FormatWithitem;
+
+impl FormatNodeRule<Withitem> for FormatWithitem {
+    fn fmt_fields(&self, _item: &Withitem, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/mod.rs

@@ -0,0 +1,8 @@
+pub(crate) mod pattern_match_as;
+pub(crate) mod pattern_match_class;
+pub(crate) mod pattern_match_mapping;
+pub(crate) mod pattern_match_or;
+pub(crate) mod pattern_match_sequence;
+pub(crate) mod pattern_match_singleton;
+pub(crate) mod pattern_match_star;
+pub(crate) mod pattern_match_value;

crates/ruff_python_formatter/src/pattern/pattern_match_as.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchAs;
+
+#[derive(Default)]
+pub struct FormatPatternMatchAs;
+
+impl FormatNodeRule<PatternMatchAs> for FormatPatternMatchAs {
+    fn fmt_fields(&self, _item: &PatternMatchAs, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_class.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchClass;
+
+#[derive(Default)]
+pub struct FormatPatternMatchClass;
+
+impl FormatNodeRule<PatternMatchClass> for FormatPatternMatchClass {
+    fn fmt_fields(&self, _item: &PatternMatchClass, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_mapping.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchMapping;
+
+#[derive(Default)]
+pub struct FormatPatternMatchMapping;
+
+impl FormatNodeRule<PatternMatchMapping> for FormatPatternMatchMapping {
+    fn fmt_fields(&self, _item: &PatternMatchMapping, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_or.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchOr;
+
+#[derive(Default)]
+pub struct FormatPatternMatchOr;
+
+impl FormatNodeRule<PatternMatchOr> for FormatPatternMatchOr {
+    fn fmt_fields(&self, _item: &PatternMatchOr, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_sequence.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchSequence;
+
+#[derive(Default)]
+pub struct FormatPatternMatchSequence;
+
+impl FormatNodeRule<PatternMatchSequence> for FormatPatternMatchSequence {
+    fn fmt_fields(&self, _item: &PatternMatchSequence, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_singleton.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchSingleton;
+
+#[derive(Default)]
+pub struct FormatPatternMatchSingleton;
+
+impl FormatNodeRule<PatternMatchSingleton> for FormatPatternMatchSingleton {
+    fn fmt_fields(&self, _item: &PatternMatchSingleton, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_star.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchStar;
+
+#[derive(Default)]
+pub struct FormatPatternMatchStar;
+
+impl FormatNodeRule<PatternMatchStar> for FormatPatternMatchStar {
+    fn fmt_fields(&self, _item: &PatternMatchStar, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/pattern/pattern_match_value.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::PatternMatchValue;
+
+#[derive(Default)]
+pub struct FormatPatternMatchValue;
+
+impl FormatNodeRule<PatternMatchValue> for FormatPatternMatchValue {
+    fn fmt_fields(&self, _item: &PatternMatchValue, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/prelude.rs

@@ -1,4 +1,4 @@
 #[allow(unused_imports)]
-pub(crate) use crate::{ASTFormatContext, AsFormat, FormattedIterExt as _, IntoFormat};
+pub(crate) use crate::{AsFormat, FormattedIterExt as _, IntoFormat, PyFormatContext};
 #[allow(unused_imports)]
 pub(crate) use ruff_formatter::prelude::*;

crates/ruff_python_formatter/src/statement/mod.rs

@@ -0,0 +1,27 @@
+pub(crate) mod stmt_ann_assign;
+pub(crate) mod stmt_assert;
+pub(crate) mod stmt_assign;
+pub(crate) mod stmt_async_for;
+pub(crate) mod stmt_async_function_def;
+pub(crate) mod stmt_async_with;
+pub(crate) mod stmt_aug_assign;
+pub(crate) mod stmt_break;
+pub(crate) mod stmt_class_def;
+pub(crate) mod stmt_continue;
+pub(crate) mod stmt_delete;
+pub(crate) mod stmt_expr;
+pub(crate) mod stmt_for;
+pub(crate) mod stmt_function_def;
+pub(crate) mod stmt_global;
+pub(crate) mod stmt_if;
+pub(crate) mod stmt_import;
+pub(crate) mod stmt_import_from;
+pub(crate) mod stmt_match;
+pub(crate) mod stmt_nonlocal;
+pub(crate) mod stmt_pass;
+pub(crate) mod stmt_raise;
+pub(crate) mod stmt_return;
+pub(crate) mod stmt_try;
+pub(crate) mod stmt_try_star;
+pub(crate) mod stmt_while;
+pub(crate) mod stmt_with;

crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAnnAssign;
+
+#[derive(Default)]
+pub struct FormatStmtAnnAssign;
+
+impl FormatNodeRule<StmtAnnAssign> for FormatStmtAnnAssign {
+    fn fmt_fields(&self, _item: &StmtAnnAssign, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_assert.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAssert;
+
+#[derive(Default)]
+pub struct FormatStmtAssert;
+
+impl FormatNodeRule<StmtAssert> for FormatStmtAssert {
+    fn fmt_fields(&self, _item: &StmtAssert, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_assign.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAssign;
+
+#[derive(Default)]
+pub struct FormatStmtAssign;
+
+impl FormatNodeRule<StmtAssign> for FormatStmtAssign {
+    fn fmt_fields(&self, _item: &StmtAssign, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_async_for.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAsyncFor;
+
+#[derive(Default)]
+pub struct FormatStmtAsyncFor;
+
+impl FormatNodeRule<StmtAsyncFor> for FormatStmtAsyncFor {
+    fn fmt_fields(&self, _item: &StmtAsyncFor, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_async_function_def.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAsyncFunctionDef;
+
+#[derive(Default)]
+pub struct FormatStmtAsyncFunctionDef;
+
+impl FormatNodeRule<StmtAsyncFunctionDef> for FormatStmtAsyncFunctionDef {
+    fn fmt_fields(&self, _item: &StmtAsyncFunctionDef, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_async_with.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAsyncWith;
+
+#[derive(Default)]
+pub struct FormatStmtAsyncWith;
+
+impl FormatNodeRule<StmtAsyncWith> for FormatStmtAsyncWith {
+    fn fmt_fields(&self, _item: &StmtAsyncWith, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtAugAssign;
+
+#[derive(Default)]
+pub struct FormatStmtAugAssign;
+
+impl FormatNodeRule<StmtAugAssign> for FormatStmtAugAssign {
+    fn fmt_fields(&self, _item: &StmtAugAssign, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_break.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtBreak;
+
+#[derive(Default)]
+pub struct FormatStmtBreak;
+
+impl FormatNodeRule<StmtBreak> for FormatStmtBreak {
+    fn fmt_fields(&self, _item: &StmtBreak, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_class_def.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtClassDef;
+
+#[derive(Default)]
+pub struct FormatStmtClassDef;
+
+impl FormatNodeRule<StmtClassDef> for FormatStmtClassDef {
+    fn fmt_fields(&self, _item: &StmtClassDef, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_continue.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtContinue;
+
+#[derive(Default)]
+pub struct FormatStmtContinue;
+
+impl FormatNodeRule<StmtContinue> for FormatStmtContinue {
+    fn fmt_fields(&self, _item: &StmtContinue, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_delete.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtDelete;
+
+#[derive(Default)]
+pub struct FormatStmtDelete;
+
+impl FormatNodeRule<StmtDelete> for FormatStmtDelete {
+    fn fmt_fields(&self, _item: &StmtDelete, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_expr.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtExpr;
+
+#[derive(Default)]
+pub struct FormatStmtExpr;
+
+impl FormatNodeRule<StmtExpr> for FormatStmtExpr {
+    fn fmt_fields(&self, _item: &StmtExpr, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_for.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtFor;
+
+#[derive(Default)]
+pub struct FormatStmtFor;
+
+impl FormatNodeRule<StmtFor> for FormatStmtFor {
+    fn fmt_fields(&self, _item: &StmtFor, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_function_def.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtFunctionDef;
+
+#[derive(Default)]
+pub struct FormatStmtFunctionDef;
+
+impl FormatNodeRule<StmtFunctionDef> for FormatStmtFunctionDef {
+    fn fmt_fields(&self, _item: &StmtFunctionDef, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_global.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtGlobal;
+
+#[derive(Default)]
+pub struct FormatStmtGlobal;
+
+impl FormatNodeRule<StmtGlobal> for FormatStmtGlobal {
+    fn fmt_fields(&self, _item: &StmtGlobal, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_if.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtIf;
+
+#[derive(Default)]
+pub struct FormatStmtIf;
+
+impl FormatNodeRule<StmtIf> for FormatStmtIf {
+    fn fmt_fields(&self, _item: &StmtIf, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_import.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtImport;
+
+#[derive(Default)]
+pub struct FormatStmtImport;
+
+impl FormatNodeRule<StmtImport> for FormatStmtImport {
+    fn fmt_fields(&self, _item: &StmtImport, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_import_from.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtImportFrom;
+
+#[derive(Default)]
+pub struct FormatStmtImportFrom;
+
+impl FormatNodeRule<StmtImportFrom> for FormatStmtImportFrom {
+    fn fmt_fields(&self, _item: &StmtImportFrom, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_match.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtMatch;
+
+#[derive(Default)]
+pub struct FormatStmtMatch;
+
+impl FormatNodeRule<StmtMatch> for FormatStmtMatch {
+    fn fmt_fields(&self, _item: &StmtMatch, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtNonlocal;
+
+#[derive(Default)]
+pub struct FormatStmtNonlocal;
+
+impl FormatNodeRule<StmtNonlocal> for FormatStmtNonlocal {
+    fn fmt_fields(&self, _item: &StmtNonlocal, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_pass.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtPass;
+
+#[derive(Default)]
+pub struct FormatStmtPass;
+
+impl FormatNodeRule<StmtPass> for FormatStmtPass {
+    fn fmt_fields(&self, _item: &StmtPass, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_raise.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtRaise;
+
+#[derive(Default)]
+pub struct FormatStmtRaise;
+
+impl FormatNodeRule<StmtRaise> for FormatStmtRaise {
+    fn fmt_fields(&self, _item: &StmtRaise, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_return.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtReturn;
+
+#[derive(Default)]
+pub struct FormatStmtReturn;
+
+impl FormatNodeRule<StmtReturn> for FormatStmtReturn {
+    fn fmt_fields(&self, _item: &StmtReturn, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_try.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtTry;
+
+#[derive(Default)]
+pub struct FormatStmtTry;
+
+impl FormatNodeRule<StmtTry> for FormatStmtTry {
+    fn fmt_fields(&self, _item: &StmtTry, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_try_star.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtTryStar;
+
+#[derive(Default)]
+pub struct FormatStmtTryStar;
+
+impl FormatNodeRule<StmtTryStar> for FormatStmtTryStar {
+    fn fmt_fields(&self, _item: &StmtTryStar, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_while.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtWhile;
+
+#[derive(Default)]
+pub struct FormatStmtWhile;
+
+impl FormatNodeRule<StmtWhile> for FormatStmtWhile {
+    fn fmt_fields(&self, _item: &StmtWhile, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_with.rs

@@ -0,0 +1,12 @@
+use crate::{FormatNodeRule, PyFormatter};
+use ruff_formatter::FormatResult;
+use rustpython_parser::ast::StmtWith;
+
+#[derive(Default)]
+pub struct FormatStmtWith;
+
+impl FormatNodeRule<StmtWith> for FormatStmtWith {
+    fn fmt_fields(&self, _item: &StmtWith, _f: &mut PyFormatter) -> FormatResult<()> {
+        Ok(())
+    }
+}