diff --git a/crates/ruff_python_formatter/generate.py b/crates/ruff_python_formatter/generate.py
index 91c1a393f7..272b0e7316 100644
--- a/crates/ruff_python_formatter/generate.py
+++ b/crates/ruff_python_formatter/generate.py
@@ -78,19 +78,19 @@ for group, group_nodes in nodes_grouped.items():
     # src.joinpath(groups[group]).joinpath("mod.rs").write_text(rustfmt(mod_section))
     for node in group_nodes:
         code = f"""
-            use crate::{{FormatNodeRule, PyFormatter}};
-            use ruff_formatter::FormatResult;
+            use crate::{{verbatim_text, FormatNodeRule, PyFormatter}};
+            use ruff_formatter::{{write, Buffer, FormatResult}};
             use rustpython_parser::ast::{node};
 
             #[derive(Default)]
             pub struct Format{node};
 
             impl FormatNodeRule<{node}> for Format{node} {{
-                fn fmt_fields(&self, _item: &{node}, _f: &mut PyFormatter) -> FormatResult<()> {{
-                    Ok(())
+                fn fmt_fields(&self, item: &{node}, f: &mut PyFormatter) -> FormatResult<()> {{
+                    write!(f, [verbatim_text(item.range)])
                 }}
             }}
-        """.strip()  # noqa: E501
+            """.strip()  # noqa: E501
         src.joinpath(groups[group]).joinpath(f"{to_camel_case(node)}.rs").write_text(
             rustfmt(code)
         )
diff --git a/crates/ruff_python_formatter/src/expression/expr_attribute.rs b/crates/ruff_python_formatter/src/expression/expr_attribute.rs
index 8e2b50263e..3c566aeae9 100644
--- a/crates/ruff_python_formatter/src/expression/expr_attribute.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_attribute.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprAttribute, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_await.rs b/crates/ruff_python_formatter/src/expression/expr_await.rs
index 0840b04b1d..4b4d74d22f 100644
--- a/crates/ruff_python_formatter/src/expression/expr_await.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_await.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprAwait, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_bin_op.rs b/crates/ruff_python_formatter/src/expression/expr_bin_op.rs
index 706c9d1f8e..102e55b2a7 100644
--- a/crates/ruff_python_formatter/src/expression/expr_bin_op.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_bin_op.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprBinOp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_bool_op.rs b/crates/ruff_python_formatter/src/expression/expr_bool_op.rs
index f7e6a92b1a..26dc802bfb 100644
--- a/crates/ruff_python_formatter/src/expression/expr_bool_op.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_bool_op.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprBoolOp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_call.rs b/crates/ruff_python_formatter/src/expression/expr_call.rs
index a5d7c6d1c9..92a9467c2d 100644
--- a/crates/ruff_python_formatter/src/expression/expr_call.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_call.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprCall, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_compare.rs b/crates/ruff_python_formatter/src/expression/expr_compare.rs
index ab1e7da1d8..b3abbe305c 100644
--- a/crates/ruff_python_formatter/src/expression/expr_compare.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_compare.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprCompare, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_constant.rs b/crates/ruff_python_formatter/src/expression/expr_constant.rs
index 91bed7bd12..c085fb409e 100644
--- a/crates/ruff_python_formatter/src/expression/expr_constant.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_constant.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprConstant, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_dict.rs b/crates/ruff_python_formatter/src/expression/expr_dict.rs
index 86b5038d92..41c1ce3db7 100644
--- a/crates/ruff_python_formatter/src/expression/expr_dict.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_dict.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprDict, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_dict_comp.rs b/crates/ruff_python_formatter/src/expression/expr_dict_comp.rs
index 315ad62fc6..9b3a7b1b78 100644
--- a/crates/ruff_python_formatter/src/expression/expr_dict_comp.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_dict_comp.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprDictComp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_formatted_value.rs b/crates/ruff_python_formatter/src/expression/expr_formatted_value.rs
index 366ecf1e7b..774e529a16 100644
--- a/crates/ruff_python_formatter/src/expression/expr_formatted_value.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_formatted_value.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprFormattedValue, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs b/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs
index 52d655b612..488279489d 100644
--- a/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_generator_exp.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprGeneratorExp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_if_exp.rs b/crates/ruff_python_formatter/src/expression/expr_if_exp.rs
index d7e8a53c6e..dd46ab26a2 100644
--- a/crates/ruff_python_formatter/src/expression/expr_if_exp.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_if_exp.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprIfExp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_joined_str.rs b/crates/ruff_python_formatter/src/expression/expr_joined_str.rs
index c0892f9b44..abf4664b74 100644
--- a/crates/ruff_python_formatter/src/expression/expr_joined_str.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_joined_str.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprJoinedStr, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_lambda.rs b/crates/ruff_python_formatter/src/expression/expr_lambda.rs
index 507c1af29b..08fd02ddb1 100644
--- a/crates/ruff_python_formatter/src/expression/expr_lambda.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_lambda.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprLambda, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_list.rs b/crates/ruff_python_formatter/src/expression/expr_list.rs
index 0161869284..105eed3916 100644
--- a/crates/ruff_python_formatter/src/expression/expr_list.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_list.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprList, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_list_comp.rs b/crates/ruff_python_formatter/src/expression/expr_list_comp.rs
index 64fe42874f..2dcd66dc76 100644
--- a/crates/ruff_python_formatter/src/expression/expr_list_comp.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_list_comp.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprListComp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_name.rs b/crates/ruff_python_formatter/src/expression/expr_name.rs
index da8294049b..b19333ff4c 100644
--- a/crates/ruff_python_formatter/src/expression/expr_name.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_name.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprName, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_named_expr.rs b/crates/ruff_python_formatter/src/expression/expr_named_expr.rs
index 457ce99d40..508d0f1c46 100644
--- a/crates/ruff_python_formatter/src/expression/expr_named_expr.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_named_expr.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprNamedExpr, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_set.rs b/crates/ruff_python_formatter/src/expression/expr_set.rs
index d1b239b925..8f1981defb 100644
--- a/crates/ruff_python_formatter/src/expression/expr_set.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_set.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprSet, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_set_comp.rs b/crates/ruff_python_formatter/src/expression/expr_set_comp.rs
index 69021f32fd..918d3526b1 100644
--- a/crates/ruff_python_formatter/src/expression/expr_set_comp.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_set_comp.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprSetComp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_slice.rs b/crates/ruff_python_formatter/src/expression/expr_slice.rs
index aa00b370f3..16b70bfba1 100644
--- a/crates/ruff_python_formatter/src/expression/expr_slice.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_slice.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprSlice, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_starred.rs b/crates/ruff_python_formatter/src/expression/expr_starred.rs
index 6a5278e0d1..8ef360db8a 100644
--- a/crates/ruff_python_formatter/src/expression/expr_starred.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_starred.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprStarred, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_subscript.rs b/crates/ruff_python_formatter/src/expression/expr_subscript.rs
index 9d68613e8d..5fe53b702c 100644
--- a/crates/ruff_python_formatter/src/expression/expr_subscript.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_subscript.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprSubscript, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_tuple.rs b/crates/ruff_python_formatter/src/expression/expr_tuple.rs
index e3eab13185..f90c9dce4e 100644
--- a/crates/ruff_python_formatter/src/expression/expr_tuple.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_tuple.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprTuple, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_unary_op.rs b/crates/ruff_python_formatter/src/expression/expr_unary_op.rs
index d6f0f0244a..35f5ae80fe 100644
--- a/crates/ruff_python_formatter/src/expression/expr_unary_op.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_unary_op.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprUnaryOp, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_yield.rs b/crates/ruff_python_formatter/src/expression/expr_yield.rs
index 26f046b3f7..697d851c80 100644
--- a/crates/ruff_python_formatter/src/expression/expr_yield.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_yield.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprYield, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/expression/expr_yield_from.rs b/crates/ruff_python_formatter/src/expression/expr_yield_from.rs
index 334bcbe3f7..164f8fabd4 100644
--- a/crates/ruff_python_formatter/src/expression/expr_yield_from.rs
+++ b/crates/ruff_python_formatter/src/expression/expr_yield_from.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ExprYieldFrom, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/lib.rs b/crates/ruff_python_formatter/src/lib.rs
index 25eae6e7ae..4604384e8c 100644
--- a/crates/ruff_python_formatter/src/lib.rs
+++ b/crates/ruff_python_formatter/src/lib.rs
@@ -1,13 +1,15 @@
 use anyhow::{anyhow, Context, Result};
+use ruff_text_size::TextRange;
 use rustpython_parser::ast::Mod;
 use rustpython_parser::lexer::lex;
 use rustpython_parser::{parse_tokens, Mode};
 
+use ruff_formatter::format_element::tag::VerbatimKind;
 use ruff_formatter::formatter::Formatter;
-use ruff_formatter::prelude::source_position;
+use ruff_formatter::prelude::{source_position, source_text_slice, ContainsNewlines, Tag};
 use ruff_formatter::{
-    format, write, Buffer, FormatResult, Formatted, IndentStyle, Printed, SimpleFormatOptions,
-    SourceCode,
+    format, write, Buffer, Format, FormatContext, FormatElement, FormatResult, Formatted,
+    IndentStyle, Printed, SimpleFormatOptions, SourceCode,
 };
 use ruff_python_ast::node::AstNode;
 use ruff_python_ast::source_code::{CommentRanges, CommentRangesBuilder, Locator};
@@ -134,6 +136,25 @@ pub fn format_node<'a>(
     )
 }
 
+pub(crate) struct VerbatimText(TextRange);
+
+pub(crate) const fn verbatim_text(range: TextRange) -> VerbatimText {
+    VerbatimText(range)
+}
+
+impl<C: FormatContext> Format<C> for VerbatimText {
+    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
+        f.write_element(FormatElement::Tag(Tag::StartVerbatim(
+            VerbatimKind::Verbatim {
+                length: self.0.len(),
+            },
+        )))?;
+        write!(f, [source_text_slice(self.0, ContainsNewlines::Detect)])?;
+        f.write_element(FormatElement::Tag(Tag::EndVerbatim))?;
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::fmt::{Formatter, Write};
diff --git a/crates/ruff_python_formatter/src/module/mod_expression.rs b/crates/ruff_python_formatter/src/module/mod_expression.rs
index 73ab6211fb..0bf1a2a5f6 100644
--- a/crates/ruff_python_formatter/src/module/mod_expression.rs
+++ b/crates/ruff_python_formatter/src/module/mod_expression.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ModExpression, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/module/mod_function_type.rs b/crates/ruff_python_formatter/src/module/mod_function_type.rs
index 5dced49b0f..90abfaa624 100644
--- a/crates/ruff_python_formatter/src/module/mod_function_type.rs
+++ b/crates/ruff_python_formatter/src/module/mod_function_type.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ModFunctionType, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/module/mod_interactive.rs b/crates/ruff_python_formatter/src/module/mod_interactive.rs
index 3dd3b3e4c6..c84e60fb27 100644
--- a/crates/ruff_python_formatter/src/module/mod_interactive.rs
+++ b/crates/ruff_python_formatter/src/module/mod_interactive.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ModInteractive, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/module/mod_module.rs b/crates/ruff_python_formatter/src/module/mod_module.rs
index 6e8fadaf41..ee353e6e5c 100644
--- a/crates/ruff_python_formatter/src/module/mod_module.rs
+++ b/crates/ruff_python_formatter/src/module/mod_module.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &ModModule, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/alias.rs b/crates/ruff_python_formatter/src/other/alias.rs
index 04187409b2..25db0f34d7 100644
--- a/crates/ruff_python_formatter/src/other/alias.rs
+++ b/crates/ruff_python_formatter/src/other/alias.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Alias, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/arg.rs b/crates/ruff_python_formatter/src/other/arg.rs
index 933468c9e8..03a6df966a 100644
--- a/crates/ruff_python_formatter/src/other/arg.rs
+++ b/crates/ruff_python_formatter/src/other/arg.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Arg, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/arguments.rs b/crates/ruff_python_formatter/src/other/arguments.rs
index 2136308466..ab4e3d1d83 100644
--- a/crates/ruff_python_formatter/src/other/arguments.rs
+++ b/crates/ruff_python_formatter/src/other/arguments.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Arguments, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/comprehension.rs b/crates/ruff_python_formatter/src/other/comprehension.rs
index 2d8324c8d7..19354cbde8 100644
--- a/crates/ruff_python_formatter/src/other/comprehension.rs
+++ b/crates/ruff_python_formatter/src/other/comprehension.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Comprehension, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/excepthandler_except_handler.rs b/crates/ruff_python_formatter/src/other/excepthandler_except_handler.rs
index cc1b78889d..ccdeb1ae0e 100644
--- a/crates/ruff_python_formatter/src/other/excepthandler_except_handler.rs
+++ b/crates/ruff_python_formatter/src/other/excepthandler_except_handler.rs
@@ -1,5 +1,5 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, FormatResult};
 use rustpython_parser::ast::ExcepthandlerExceptHandler;
 
 #[derive(Default)]
@@ -8,9 +8,9 @@ pub struct FormatExcepthandlerExceptHandler;
 impl FormatNodeRule<ExcepthandlerExceptHandler> for FormatExcepthandlerExceptHandler {
     fn fmt_fields(
         &self,
-        _item: &ExcepthandlerExceptHandler,
-        _f: &mut PyFormatter,
+        item: &ExcepthandlerExceptHandler,
+        f: &mut PyFormatter,
     ) -> FormatResult<()> {
-        Ok(())
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/keyword.rs b/crates/ruff_python_formatter/src/other/keyword.rs
index ade4d731b1..078429f980 100644
--- a/crates/ruff_python_formatter/src/other/keyword.rs
+++ b/crates/ruff_python_formatter/src/other/keyword.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Keyword, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/match_case.rs b/crates/ruff_python_formatter/src/other/match_case.rs
index a3e3d134d9..af486257f5 100644
--- a/crates/ruff_python_formatter/src/other/match_case.rs
+++ b/crates/ruff_python_formatter/src/other/match_case.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &MatchCase, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs b/crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs
index bb493395a6..937e99db7c 100644
--- a/crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs
+++ b/crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &TypeIgnoreTypeIgnore, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/other/withitem.rs b/crates/ruff_python_formatter/src/other/withitem.rs
index 145b4a72d9..3b8ace3eb0 100644
--- a/crates/ruff_python_formatter/src/other/withitem.rs
+++ b/crates/ruff_python_formatter/src/other/withitem.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &Withitem, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_as.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_as.rs
index c9508a4e1f..c91b210e3f 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_as.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_as.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchAs, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_class.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_class.rs
index 897e1797de..e1987acd95 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_class.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_class.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchClass, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_mapping.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_mapping.rs
index 8f6ba2caf4..0afe64d3c8 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_mapping.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_mapping.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchMapping, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_or.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_or.rs
index 5b2dcaa63c..2fa18ac9e8 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_or.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_or.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchOr, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_sequence.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_sequence.rs
index 41c2b39545..6159a17490 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_sequence.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_sequence.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchSequence, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_singleton.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_singleton.rs
index b01f04a12f..a35b506e16 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_singleton.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_singleton.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchSingleton, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_star.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_star.rs
index 2a5f621a22..cd5f4976f5 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_star.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_star.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchStar, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/pattern/pattern_match_value.rs b/crates/ruff_python_formatter/src/pattern/pattern_match_value.rs
index 72afeaa89e..4d14f2aad0 100644
--- a/crates/ruff_python_formatter/src/pattern/pattern_match_value.rs
+++ b/crates/ruff_python_formatter/src/pattern/pattern_match_value.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &PatternMatchValue, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs b/crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs
index 90bd9c6ab8..721c219304 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_ann_assign.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAnnAssign, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_assert.rs b/crates/ruff_python_formatter/src/statement/stmt_assert.rs
index 274260b3af..1cd34b93a5 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_assert.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_assert.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAssert, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_assign.rs b/crates/ruff_python_formatter/src/statement/stmt_assign.rs
index a24d2cb561..3b7d95c8da 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_assign.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_assign.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAssign, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_async_for.rs b/crates/ruff_python_formatter/src/statement/stmt_async_for.rs
index d83d8314cf..d69c0ecf26 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_async_for.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_async_for.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAsyncFor, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_async_function_def.rs b/crates/ruff_python_formatter/src/statement/stmt_async_function_def.rs
index 15dff5ba19..e3bd34df1b 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_async_function_def.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_async_function_def.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAsyncFunctionDef, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_async_with.rs b/crates/ruff_python_formatter/src/statement/stmt_async_with.rs
index 16ebedea9f..1ce677f4d9 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_async_with.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_async_with.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAsyncWith, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs b/crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs
index 2574262504..34f9a299c5 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_aug_assign.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtAugAssign, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_break.rs b/crates/ruff_python_formatter/src/statement/stmt_break.rs
index 1e1b600166..8ad401b17a 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_break.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_break.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtBreak, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_class_def.rs b/crates/ruff_python_formatter/src/statement/stmt_class_def.rs
index c08da73bde..69f5a77c49 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_class_def.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_class_def.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtClassDef, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_continue.rs b/crates/ruff_python_formatter/src/statement/stmt_continue.rs
index 7f684c9f0f..461d4dc431 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_continue.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_continue.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtContinue, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_delete.rs b/crates/ruff_python_formatter/src/statement/stmt_delete.rs
index 8ada8b86ec..1b446a16fa 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_delete.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_delete.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtDelete, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_expr.rs b/crates/ruff_python_formatter/src/statement/stmt_expr.rs
index 03952de865..b19a723837 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_expr.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_expr.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtExpr, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_for.rs b/crates/ruff_python_formatter/src/statement/stmt_for.rs
index 57d50fbe4d..11c162ebf0 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_for.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_for.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtFor, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_function_def.rs b/crates/ruff_python_formatter/src/statement/stmt_function_def.rs
index 153014b411..c8263f07c3 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_function_def.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_function_def.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtFunctionDef, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_global.rs b/crates/ruff_python_formatter/src/statement/stmt_global.rs
index ee3ced3b32..a7b73a55fe 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_global.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_global.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtGlobal, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_if.rs b/crates/ruff_python_formatter/src/statement/stmt_if.rs
index 788ed54266..94a2715d33 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_if.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_if.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtIf, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_import.rs b/crates/ruff_python_formatter/src/statement/stmt_import.rs
index 3bfd9e8048..fa1f7bfdf7 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_import.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_import.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtImport, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_import_from.rs b/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
index ab33945941..4d1d7c2371 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_import_from.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtImportFrom, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_match.rs b/crates/ruff_python_formatter/src/statement/stmt_match.rs
index d2b2e12d48..aac63a7730 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_match.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_match.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtMatch, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs b/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
index 33a9cabda3..feb4056513 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_nonlocal.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtNonlocal, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_pass.rs b/crates/ruff_python_formatter/src/statement/stmt_pass.rs
index edc11dca8c..fdffb521ce 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_pass.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_pass.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtPass, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_raise.rs b/crates/ruff_python_formatter/src/statement/stmt_raise.rs
index 433eacb4db..d480275a44 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_raise.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_raise.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtRaise, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_return.rs b/crates/ruff_python_formatter/src/statement/stmt_return.rs
index 0cd6790cd5..1da4170f9f 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_return.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_return.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtReturn, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_try.rs b/crates/ruff_python_formatter/src/statement/stmt_try.rs
index 84bdec3b6e..c2bceff327 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_try.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_try.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtTry, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_try_star.rs b/crates/ruff_python_formatter/src/statement/stmt_try_star.rs
index 4080bf9349..098966fb7f 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_try_star.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_try_star.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtTryStar, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_while.rs b/crates/ruff_python_formatter/src/statement/stmt_while.rs
index 157f69fb26..c11cd9cbf4 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_while.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_while.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtWhile, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }
diff --git a/crates/ruff_python_formatter/src/statement/stmt_with.rs b/crates/ruff_python_formatter/src/statement/stmt_with.rs
index f0d1c26735..ab19089eda 100644
--- a/crates/ruff_python_formatter/src/statement/stmt_with.rs
+++ b/crates/ruff_python_formatter/src/statement/stmt_with.rs
@@ -1,12 +1,12 @@
-use crate::{FormatNodeRule, PyFormatter};
-use ruff_formatter::FormatResult;
+use crate::{verbatim_text, FormatNodeRule, PyFormatter};
+use ruff_formatter::{write, Buffer, 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(())
+    fn fmt_fields(&self, item: &StmtWith, f: &mut PyFormatter) -> FormatResult<()> {
+        write!(f, [verbatim_text(item.range)])
     }
 }