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/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;