Update formatter with FString*Element nodes

Author: dhruvmanila

crates/ruff_python_formatter/src/expression/string/mod.rs

@@ -52,16 +52,19 @@ impl<'a> AnyString<'a> {
                     .trim_start_matches(|c| c != '"' && c != '\'');
                 let triple_quoted =
                     unprefixed.starts_with(r#"""""#) || unprefixed.starts_with(r"'''");
-                if f_string.value.elements().any(|value| match value {
-                    Expr::FormattedValue(ast::ExprFormattedValue { range, .. }) => {
+                if f_string.value.elements().any(|element| match element {
+                    ast::FStringElement::Expression(ast::FStringExpressionElement {
+                        range,
+                        ..
+                    }) => {
                         let string_content = locator.slice(*range);
                         if triple_quoted {
                             string_content.contains(r#"""""#) || string_content.contains("'''")
                         } else {
                             string_content.contains(['"', '\''])
                         }
                     }
-                    _ => false,
+                    ast::FStringElement::Literal(_) => false,
                 }) {
                     Quoting::Preserve
                 } else {

crates/ruff_python_formatter/src/generated.rs

@@ -1534,42 +1534,6 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExprCall {
     }
 }
 
-impl FormatRule<ast::ExprFormattedValue, PyFormatContext<'_>>
-    for crate::expression::expr_formatted_value::FormatExprFormattedValue
-{
-    #[inline]
-    fn fmt(&self, node: &ast::ExprFormattedValue, f: &mut PyFormatter) -> FormatResult<()> {
-        FormatNodeRule::<ast::ExprFormattedValue>::fmt(self, node, f)
-    }
-}
-impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::ExprFormattedValue {
-    type Format<'a> = FormatRefWithRule<
-        'a,
-        ast::ExprFormattedValue,
-        crate::expression::expr_formatted_value::FormatExprFormattedValue,
-        PyFormatContext<'ast>,
-    >;
-    fn format(&self) -> Self::Format<'_> {
-        FormatRefWithRule::new(
-            self,
-            crate::expression::expr_formatted_value::FormatExprFormattedValue::default(),
-        )
-    }
-}
-impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExprFormattedValue {
-    type Format = FormatOwnedWithRule<
-        ast::ExprFormattedValue,
-        crate::expression::expr_formatted_value::FormatExprFormattedValue,
-        PyFormatContext<'ast>,
-    >;
-    fn into_format(self) -> Self::Format {
-        FormatOwnedWithRule::new(
-            self,
-            crate::expression::expr_formatted_value::FormatExprFormattedValue::default(),
-        )
-    }
-}
-
 impl FormatRule<ast::ExprFString, PyFormatContext<'_>>
     for crate::expression::expr_f_string::FormatExprFString
 {
@@ -2148,6 +2112,78 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExceptHandlerExceptHandler
     }
 }
 
+impl FormatRule<ast::FStringExpressionElement, PyFormatContext<'_>>
+    for crate::other::f_string_expression_element::FormatFStringExpressionElement
+{
+    #[inline]
+    fn fmt(&self, node: &ast::FStringExpressionElement, f: &mut PyFormatter) -> FormatResult<()> {
+        FormatNodeRule::<ast::FStringExpressionElement>::fmt(self, node, f)
+    }
+}
+impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::FStringExpressionElement {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        ast::FStringExpressionElement,
+        crate::other::f_string_expression_element::FormatFStringExpressionElement,
+        PyFormatContext<'ast>,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::other::f_string_expression_element::FormatFStringExpressionElement::default(),
+        )
+    }
+}
+impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::FStringExpressionElement {
+    type Format = FormatOwnedWithRule<
+        ast::FStringExpressionElement,
+        crate::other::f_string_expression_element::FormatFStringExpressionElement,
+        PyFormatContext<'ast>,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::other::f_string_expression_element::FormatFStringExpressionElement::default(),
+        )
+    }
+}
+
+impl FormatRule<ast::FStringLiteralElement, PyFormatContext<'_>>
+    for crate::other::f_string_literal_element::FormatFStringLiteralElement
+{
+    #[inline]
+    fn fmt(&self, node: &ast::FStringLiteralElement, f: &mut PyFormatter) -> FormatResult<()> {
+        FormatNodeRule::<ast::FStringLiteralElement>::fmt(self, node, f)
+    }
+}
+impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::FStringLiteralElement {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        ast::FStringLiteralElement,
+        crate::other::f_string_literal_element::FormatFStringLiteralElement,
+        PyFormatContext<'ast>,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::other::f_string_literal_element::FormatFStringLiteralElement::default(),
+        )
+    }
+}
+impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::FStringLiteralElement {
+    type Format = FormatOwnedWithRule<
+        ast::FStringLiteralElement,
+        crate::other::f_string_literal_element::FormatFStringLiteralElement,
+        PyFormatContext<'ast>,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::other::f_string_literal_element::FormatFStringLiteralElement::default(),
+        )
+    }
+}
+
 impl FormatRule<ast::PatternMatchValue, PyFormatContext<'_>>
     for crate::pattern::pattern_match_value::FormatPatternMatchValue
 {

crates/ruff_python_formatter/src/other/f_string_expression_element.rs

@@ -0,0 +1,16 @@
+use ruff_python_ast::FStringExpressionElement;
+
+use crate::prelude::*;
+
+#[derive(Default)]
+pub struct FormatFStringExpressionElement;
+
+impl FormatNodeRule<FStringExpressionElement> for FormatFStringExpressionElement {
+    fn fmt_fields(
+        &self,
+        _item: &FStringExpressionElement,
+        _f: &mut PyFormatter,
+    ) -> FormatResult<()> {
+        unreachable!("Handled inside of `FormatExprFString");
+    }
+}

crates/ruff_python_formatter/src/other/f_string_literal_element.rs

@@ -0,0 +1,12 @@
+use ruff_python_ast::FStringLiteralElement;
+
+use crate::prelude::*;
+
+#[derive(Default)]
+pub struct FormatFStringLiteralElement;
+
+impl FormatNodeRule<FStringLiteralElement> for FormatFStringLiteralElement {
+    fn fmt_fields(&self, _item: &FStringLiteralElement, _f: &mut PyFormatter) -> FormatResult<()> {
+        unreachable!("Handled inside of `FormatExprFString");
+    }
+}

crates/ruff_python_formatter/src/other/mod.rs

@@ -7,6 +7,8 @@ pub(crate) mod decorator;
 pub(crate) mod elif_else_clause;
 pub(crate) mod except_handler_except_handler;
 pub(crate) mod f_string;
+pub(crate) mod f_string_expression_element;
+pub(crate) mod f_string_literal_element;
 pub(crate) mod identifier;
 pub(crate) mod keyword;
 pub(crate) mod match_case;