From 253f5f269a00ca8717086d1a232ca96b616e8952 Mon Sep 17 00:00:00 2001 From: Micha Reiser Date: Fri, 27 Sep 2024 10:24:50 +0200 Subject: [PATCH] refactor: Rename `FormatStringContinuation` to `FormatImplicitConcatenatedString` (#13531) --- .../src/expression/binary_like.rs | 10 +++++----- .../src/expression/expr_bytes_literal.rs | 5 ++--- .../src/expression/expr_f_string.rs | 7 ++----- .../src/expression/expr_string_literal.rs | 4 ++-- .../ruff_python_formatter/src/string/any.rs | 18 ++++++++++++++++++ .../ruff_python_formatter/src/string/mod.rs | 19 +++++++++++-------- 6 files changed, 40 insertions(+), 23 deletions(-) diff --git a/crates/ruff_python_formatter/src/expression/binary_like.rs b/crates/ruff_python_formatter/src/expression/binary_like.rs index d0113682b4..95cb9a3c3a 100644 --- a/crates/ruff_python_formatter/src/expression/binary_like.rs +++ b/crates/ruff_python_formatter/src/expression/binary_like.rs @@ -20,7 +20,7 @@ use crate::expression::parentheses::{ }; use crate::expression::OperatorPrecedence; use crate::prelude::*; -use crate::string::{AnyString, FormatStringContinuation}; +use crate::string::{AnyString, FormatImplicitConcatenatedString}; #[derive(Copy, Clone, Debug)] pub(super) enum BinaryLike<'a> { @@ -394,10 +394,10 @@ impl Format> for BinaryLike<'_> { [ operand.leading_binary_comments().map(leading_comments), leading_comments(comments.leading(string_constant)), - // Call `FormatStringContinuation` directly to avoid formatting + // Call `FormatImplicitConcatenatedString` directly to avoid formatting // the implicitly concatenated string with the enclosing group // because the group is added by the binary like formatting. - FormatStringContinuation::new(&string_constant), + FormatImplicitConcatenatedString::new(string_constant), trailing_comments(comments.trailing(string_constant)), operand.trailing_binary_comments().map(trailing_comments), line_suffix_boundary(), @@ -413,10 +413,10 @@ impl Format> for BinaryLike<'_> { f, [ leading_comments(comments.leading(string_constant)), - // Call `FormatStringContinuation` directly to avoid formatting + // Call `FormatImplicitConcatenatedString` directly to avoid formatting // the implicitly concatenated string with the enclosing group // because the group is added by the binary like formatting. - FormatStringContinuation::new(&string_constant), + FormatImplicitConcatenatedString::new(string_constant), trailing_comments(comments.trailing(string_constant)), ] )?; diff --git a/crates/ruff_python_formatter/src/expression/expr_bytes_literal.rs b/crates/ruff_python_formatter/src/expression/expr_bytes_literal.rs index 154780e3e5..132f08b9d6 100644 --- a/crates/ruff_python_formatter/src/expression/expr_bytes_literal.rs +++ b/crates/ruff_python_formatter/src/expression/expr_bytes_literal.rs @@ -5,7 +5,7 @@ use crate::expression::parentheses::{ in_parentheses_only_group, NeedsParentheses, OptionalParentheses, }; use crate::prelude::*; -use crate::string::{AnyString, FormatStringContinuation}; +use crate::string::{AnyString, FormatImplicitConcatenatedString}; #[derive(Default)] pub struct FormatExprBytesLiteral; @@ -16,8 +16,7 @@ impl FormatNodeRule for FormatExprBytesLiteral { match value.as_slice() { [bytes_literal] => bytes_literal.format().fmt(f), - _ => in_parentheses_only_group(&FormatStringContinuation::new(&AnyString::Bytes(item))) - .fmt(f), + _ => in_parentheses_only_group(&FormatImplicitConcatenatedString::new(item)).fmt(f), } } } diff --git a/crates/ruff_python_formatter/src/expression/expr_f_string.rs b/crates/ruff_python_formatter/src/expression/expr_f_string.rs index 455b2943e6..1690eca9a3 100644 --- a/crates/ruff_python_formatter/src/expression/expr_f_string.rs +++ b/crates/ruff_python_formatter/src/expression/expr_f_string.rs @@ -7,7 +7,7 @@ use crate::expression::parentheses::{ }; use crate::other::f_string_part::FormatFStringPart; use crate::prelude::*; -use crate::string::{AnyString, FormatStringContinuation, Quoting}; +use crate::string::{AnyString, FormatImplicitConcatenatedString, Quoting}; #[derive(Default)] pub struct FormatExprFString; @@ -22,10 +22,7 @@ impl FormatNodeRule for FormatExprFString { f_string_quoting(item, &f.context().locator()), ) .fmt(f), - _ => { - in_parentheses_only_group(&FormatStringContinuation::new(&AnyString::FString(item))) - .fmt(f) - } + _ => in_parentheses_only_group(&FormatImplicitConcatenatedString::new(item)).fmt(f), } } } diff --git a/crates/ruff_python_formatter/src/expression/expr_string_literal.rs b/crates/ruff_python_formatter/src/expression/expr_string_literal.rs index 8c227f5de3..460c1519dd 100644 --- a/crates/ruff_python_formatter/src/expression/expr_string_literal.rs +++ b/crates/ruff_python_formatter/src/expression/expr_string_literal.rs @@ -6,7 +6,7 @@ use crate::expression::parentheses::{ }; use crate::other::string_literal::{FormatStringLiteral, StringLiteralKind}; use crate::prelude::*; -use crate::string::{AnyString, FormatStringContinuation}; +use crate::string::{AnyString, FormatImplicitConcatenatedString}; #[derive(Default)] pub struct FormatExprStringLiteral { @@ -55,7 +55,7 @@ impl FormatNodeRule for FormatExprStringLiteral { // ensures that the docstring is a *single* string literal. assert!(!self.kind.is_docstring()); - in_parentheses_only_group(&FormatStringContinuation::new(&AnyString::String(item))) + in_parentheses_only_group(&FormatImplicitConcatenatedString::new(item)) } .fmt(f), } diff --git a/crates/ruff_python_formatter/src/string/any.rs b/crates/ruff_python_formatter/src/string/any.rs index b621027c28..b86b3b4fc0 100644 --- a/crates/ruff_python_formatter/src/string/any.rs +++ b/crates/ruff_python_formatter/src/string/any.rs @@ -118,6 +118,24 @@ impl<'a> From<&AnyString<'a>> for ExpressionRef<'a> { } } +impl<'a> From<&'a ExprBytesLiteral> for AnyString<'a> { + fn from(value: &'a ExprBytesLiteral) -> Self { + AnyString::Bytes(value) + } +} + +impl<'a> From<&'a ExprStringLiteral> for AnyString<'a> { + fn from(value: &'a ExprStringLiteral) -> Self { + AnyString::String(value) + } +} + +impl<'a> From<&'a ExprFString> for AnyString<'a> { + fn from(value: &'a ExprFString) -> Self { + AnyString::FString(value) + } +} + pub(super) enum AnyStringPartsIter<'a> { String(std::slice::Iter<'a, StringLiteral>), Bytes(std::slice::Iter<'a, ast::BytesLiteral>), diff --git a/crates/ruff_python_formatter/src/string/mod.rs b/crates/ruff_python_formatter/src/string/mod.rs index 73171f9e8b..bdaba1a7d7 100644 --- a/crates/ruff_python_formatter/src/string/mod.rs +++ b/crates/ruff_python_formatter/src/string/mod.rs @@ -27,17 +27,19 @@ pub(crate) enum Quoting { /// Formats any implicitly concatenated string. This could be any valid combination /// of string, bytes or f-string literals. -pub(crate) struct FormatStringContinuation<'a> { - string: &'a AnyString<'a>, +pub(crate) struct FormatImplicitConcatenatedString<'a> { + string: AnyString<'a>, } -impl<'a> FormatStringContinuation<'a> { - pub(crate) fn new(string: &'a AnyString<'a>) -> Self { - Self { string } +impl<'a> FormatImplicitConcatenatedString<'a> { + pub(crate) fn new(string: impl Into>) -> Self { + Self { + string: string.into(), + } } } -impl Format> for FormatStringContinuation<'_> { +impl Format> for FormatImplicitConcatenatedString<'_> { fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> { let comments = f.context().comments().clone(); let quoting = self.string.quoting(&f.context().locator()); @@ -45,11 +47,12 @@ impl Format> for FormatStringContinuation<'_> { let mut joiner = f.join_with(in_parentheses_only_soft_line_break_or_space()); for part in self.string.parts(quoting) { + let part_comments = comments.leading_dangling_trailing(&part); joiner.entry(&format_args![ line_suffix_boundary(), - leading_comments(comments.leading(&part)), + leading_comments(part_comments.leading), part, - trailing_comments(comments.trailing(&part)) + trailing_comments(part_comments.trailing) ]); }