From b00bbf43ee98b25e947624b36e566109112cdc0a Mon Sep 17 00:00:00 2001 From: Brent Westbrook Date: Wed, 10 Dec 2025 14:44:14 -0500 Subject: [PATCH] rewrap long lines --- .../src/comments/node_key.rs | 3 +- .../src/comments/placement.rs | 8 ++--- .../src/comments/visitor.rs | 3 +- .../src/expression/binary_like.rs | 6 ++-- .../src/expression/parentheses.rs | 14 +++++---- .../ruff_python_formatter/src/pattern/mod.rs | 5 ++-- .../src/pattern/pattern_arguments.rs | 5 ++-- crates/ruff_python_formatter/src/range.rs | 30 ++++++++++++------- .../src/statement/stmt_assign.rs | 13 ++++---- .../src/statement/stmt_with.rs | 6 ++-- .../src/string/normalize.rs | 5 ++-- crates/ruff_python_formatter/src/verbatim.rs | 5 ++-- 12 files changed, 60 insertions(+), 43 deletions(-) diff --git a/crates/ruff_python_formatter/src/comments/node_key.rs b/crates/ruff_python_formatter/src/comments/node_key.rs index 22f4582132..115a751150 100644 --- a/crates/ruff_python_formatter/src/comments/node_key.rs +++ b/crates/ruff_python_formatter/src/comments/node_key.rs @@ -2,7 +2,8 @@ use ruff_python_ast::AnyNodeRef; use std::fmt::{Debug, Formatter}; use std::hash::{Hash, Hasher}; -/// Used as key into the [`MultiMap`](super::MultiMap) storing the comments per node by [`Comments`](super::Comments). +/// Used as key into the [`MultiMap`](super::MultiMap) storing the comments per node by +/// [`Comments`](super::Comments). /// /// Implements equality and hashing based on the address of the [`AnyNodeRef`] to get fast and cheap /// hashing/equality comparison. diff --git a/crates/ruff_python_formatter/src/comments/placement.rs b/crates/ruff_python_formatter/src/comments/placement.rs index c9b71d0f21..ff38d7a100 100644 --- a/crates/ruff_python_formatter/src/comments/placement.rs +++ b/crates/ruff_python_formatter/src/comments/placement.rs @@ -1974,8 +1974,8 @@ fn handle_unary_op_comment<'a>( /// ) /// ``` /// -/// The comment will be attached to the [`Arguments`](ast::Arguments) node as a dangling comment, to ensure -/// that it remains on the same line as open parenthesis. +/// The comment will be attached to the [`Arguments`](ast::Arguments) node as a dangling comment, to +/// ensure that it remains on the same line as open parenthesis. /// /// Similarly, given: /// ```python @@ -1984,8 +1984,8 @@ fn handle_unary_op_comment<'a>( /// ] = ... /// ``` /// -/// The comment will be attached to the [`TypeParams`](ast::TypeParams) node as a dangling comment, to ensure -/// that it remains on the same line as open bracket. +/// The comment will be attached to the [`TypeParams`](ast::TypeParams) node as a dangling comment, +/// to ensure that it remains on the same line as open bracket. fn handle_bracketed_end_of_line_comment<'a>( comment: DecoratedComment<'a>, source: &str, diff --git a/crates/ruff_python_formatter/src/comments/visitor.rs b/crates/ruff_python_formatter/src/comments/visitor.rs index 786fa7a574..1aad7e273d 100644 --- a/crates/ruff_python_formatter/src/comments/visitor.rs +++ b/crates/ruff_python_formatter/src/comments/visitor.rs @@ -174,7 +174,8 @@ impl<'ast> SourceOrderVisitor<'ast> for CommentsVisitor<'ast, '_> { /// A comment decorated with additional information about its surrounding context in the source document. /// -/// Used by [`place_comment`] to determine if this should become a [leading](self#leading-comments), [dangling](self#dangling-comments), or [trailing](self#trailing-comments) comment. +/// Used by [`place_comment`] to determine if this should become a [leading](self#leading-comments), +/// [dangling](self#dangling-comments), or [trailing](self#trailing-comments) comment. #[derive(Debug, Clone)] pub(crate) struct DecoratedComment<'a> { enclosing: AnyNodeRef<'a>, diff --git a/crates/ruff_python_formatter/src/expression/binary_like.rs b/crates/ruff_python_formatter/src/expression/binary_like.rs index 7363e67cd0..f1da88299d 100644 --- a/crates/ruff_python_formatter/src/expression/binary_like.rs +++ b/crates/ruff_python_formatter/src/expression/binary_like.rs @@ -1095,9 +1095,9 @@ impl OperandIndex { } } - /// Returns the index of the operand's right operator. The method always returns an index - /// even if the operand has no right operator. Use [`FlatBinaryExpressionSlice::get_operator`] to test if - /// the operand has a right operator. + /// Returns the index of the operand's right operator. The method always returns an index even + /// if the operand has no right operator. Use [`FlatBinaryExpressionSlice::get_operator`] to + /// test if the operand has a right operator. fn right_operator(self) -> OperatorIndex { OperatorIndex::new(self.0 + 1) } diff --git a/crates/ruff_python_formatter/src/expression/parentheses.rs b/crates/ruff_python_formatter/src/expression/parentheses.rs index c3ee1c7ee7..18b9b274c1 100644 --- a/crates/ruff_python_formatter/src/expression/parentheses.rs +++ b/crates/ruff_python_formatter/src/expression/parentheses.rs @@ -56,18 +56,20 @@ pub(crate) enum Parenthesize { /// Adding parentheses is desired to prevent the comments from wandering. IfRequired, - /// Same as [`Self::IfBreaks`] except that it uses [`parenthesize_if_expands`](crate::builders::parenthesize_if_expands) for expressions - /// with the layout [`OptionalParentheses::BestFit`] which is used by non-splittable - /// expressions like literals, name, and strings. + /// Same as [`Self::IfBreaks`] except that it uses + /// [`parenthesize_if_expands`](crate::builders::parenthesize_if_expands) for expressions with + /// the layout [`OptionalParentheses::BestFit`] which is used by non-splittable expressions like + /// literals, name, and strings. /// /// Use this layout over `IfBreaks` when there's a sequence of `maybe_parenthesize_expression` /// in a single logical-line and you want to break from right-to-left. Use `IfBreaks` for the /// first expression and `IfBreaksParenthesized` for the rest. IfBreaksParenthesized, - /// Same as [`Self::IfBreaksParenthesized`] but uses [`parenthesize_if_expands`](crate::builders::parenthesize_if_expands) for nested - /// [`maybe_parenthesized_expression`](crate::expression::maybe_parenthesize_expression) calls unlike other layouts that always omit parentheses - /// when outer parentheses are present. + /// Same as [`Self::IfBreaksParenthesized`] but uses + /// [`parenthesize_if_expands`](crate::builders::parenthesize_if_expands) for nested + /// [`maybe_parenthesized_expression`](crate::expression::maybe_parenthesize_expression) calls + /// unlike other layouts that always omit parentheses when outer parentheses are present. IfBreaksParenthesizedNested, } diff --git a/crates/ruff_python_formatter/src/pattern/mod.rs b/crates/ruff_python_formatter/src/pattern/mod.rs index dc188095ef..ac763a41ff 100644 --- a/crates/ruff_python_formatter/src/pattern/mod.rs +++ b/crates/ruff_python_formatter/src/pattern/mod.rs @@ -214,8 +214,9 @@ impl Format> for MaybeParenthesizePattern<'_> { } } -/// This function is very similar to [`can_omit_optional_parentheses`](crate::expression::can_omit_optional_parentheses) with the only difference that it is for patterns -/// and not expressions. +/// This function is very similar to +/// [`can_omit_optional_parentheses`](crate::expression::can_omit_optional_parentheses) +/// with the only difference that it is for patterns and not expressions. /// /// The base idea of the omit optional parentheses layout is to prefer using parentheses of sub-patterns /// when splitting the pattern over introducing new patterns. For example, prefer splitting the sequence pattern in diff --git a/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs b/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs index fb3382e7d9..d82a9756e0 100644 --- a/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs +++ b/crates/ruff_python_formatter/src/pattern/pattern_arguments.rs @@ -72,8 +72,9 @@ impl FormatNodeRule for FormatPatternArguments { } } -/// Returns `true` if the pattern (which is the only argument to a [`PatternMatchClass`](ruff_python_ast::PatternMatchClass)) is -/// parenthesized. Used to avoid falsely assuming that `x` is parenthesized in cases like: +/// Returns `true` if the pattern (which is the only argument to a +/// [`PatternMatchClass`](ruff_python_ast::PatternMatchClass)) is parenthesized. +/// Used to avoid falsely assuming that `x` is parenthesized in cases like: /// ```python /// case Point2D(x): ... /// ``` diff --git a/crates/ruff_python_formatter/src/range.rs b/crates/ruff_python_formatter/src/range.rs index be63c69c78..ccc7a51aba 100644 --- a/crates/ruff_python_formatter/src/range.rs +++ b/crates/ruff_python_formatter/src/range.rs @@ -23,7 +23,8 @@ use crate::{FormatModuleError, PyFormatOptions, format_module_source}; /// /// The returned formatted range guarantees to cover at least `range` (excluding whitespace), but the range might be larger. /// Some cases in which the returned range is larger than `range` are: -/// * The logical lines in `range` use a indentation different from the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth). +/// * The logical lines in `range` use a indentation different from the configured [`IndentStyle`] +/// and [`IndentWidth`](ruff_formatter::IndentWidth). /// * `range` is smaller than a logical lines and the formatter needs to format the entire logical line. /// * `range` falls on a single line body. /// @@ -129,16 +130,19 @@ pub fn format_range( /// b) formatting a sub-expression has fewer split points than formatting the entire expressions. /// /// ### Possible docstrings -/// Strings that are suspected to be docstrings are excluded from the search to format the enclosing suite instead -/// so that the formatter's docstring detection in [`FormatSuite`](crate::statement::suite::FormatSuite) correctly detects and formats the docstrings. +/// Strings that are suspected to be docstrings are excluded from the search to format the enclosing +/// suite instead so that the formatter's docstring detection in +/// [`FormatSuite`](crate::statement::suite::FormatSuite) correctly detects and formats the +/// docstrings. /// /// ### Compound statements with a simple statement body /// Don't include simple-statement bodies of compound statements `if True: pass` because the formatter /// must run `FormatClauseBody` to determine if the body should be collapsed or not. /// /// ### Incorrectly indented code -/// Code that uses indentations that don't match the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth) are excluded from the search, -/// because formatting such nodes on their own can lead to indentation mismatch with its sibling nodes. +/// Code that uses indentations that don't match the configured [`IndentStyle`] and +/// [`IndentWidth`](ruff_formatter::IndentWidth) are excluded from the search, because formatting +/// such nodes on their own can lead to indentation mismatch with its sibling nodes. /// /// ## Suppression comments /// The search ends when `range` falls into a suppressed range because there's nothing to format. It also avoids that the @@ -282,10 +286,12 @@ enum EnclosingNode<'a> { /// with the body. This ensures that the formatter runs `FormatClauseBody` that determines if the body should be indented. /// /// ## Non-standard indentation -/// Node's that use an indentation that doesn't match the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth) are excluded from the search. -/// This is because the formatter always uses the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth), resulting in the -/// formatted nodes using a different indentation than the unformatted sibling nodes. This would be tolerable -/// in non whitespace sensitive languages like JavaScript but results in lexical errors in Python. +/// Nodes that use an indentation that doesn't match the configured [`IndentStyle`] and +/// [`IndentWidth`](ruff_formatter::IndentWidth) are excluded from the search. This is because the +/// formatter always uses the configured [`IndentStyle`] and +/// [`IndentWidth`](ruff_formatter::IndentWidth), resulting in the formatted nodes using a different +/// indentation than the unformatted sibling nodes. This would be tolerable in non whitespace +/// sensitive languages like JavaScript but results in lexical errors in Python. /// /// ## Implementation /// It would probably be possible to merge this visitor with [`FindEnclosingNode`] but they are separate because @@ -713,9 +719,11 @@ impl Format> for FormatEnclosingNode<'_> { } } -/// Computes the level of indentation for `indentation` when using the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth). +/// Computes the level of indentation for `indentation` when using the configured [`IndentStyle`] +/// and [`IndentWidth`](ruff_formatter::IndentWidth). /// -/// Returns `None` if the indentation doesn't conform to the configured [`IndentStyle`] and [`IndentWidth`](ruff_formatter::IndentWidth). +/// Returns `None` if the indentation doesn't conform to the configured [`IndentStyle`] and +/// [`IndentWidth`](ruff_formatter::IndentWidth). /// /// # Panics /// If `offset` is outside of `source`. diff --git a/crates/ruff_python_formatter/src/statement/stmt_assign.rs b/crates/ruff_python_formatter/src/statement/stmt_assign.rs index f213654010..5a16e5e8bf 100644 --- a/crates/ruff_python_formatter/src/statement/stmt_assign.rs +++ b/crates/ruff_python_formatter/src/statement/stmt_assign.rs @@ -202,8 +202,8 @@ pub(super) enum FormatStatementsLastExpression<'a> { /// ] = some_long_value /// ``` /// - /// This layout is preferred over [`Self::RightToLeft`] if the left is unsplittable (single keyword like `return` or a Name) - /// because it has better performance characteristics. + /// This layout is preferred over [`Self::RightToLeft`] if the left is unsplittable (single + /// keyword like `return` or a Name) because it has better performance characteristics. LeftToRight { /// The right side of an assignment or the value returned in a return statement. value: &'a Expr, @@ -1083,11 +1083,10 @@ impl Format> for InterpolatedString<'_> { /// For legibility, we discuss only the case of f-strings below, but the /// same comments apply to t-strings. /// -/// This is just a wrapper around [`FormatFString`](crate::other::f_string::FormatFString) while considering a special -/// case when the f-string is at an assignment statement's value position. -/// This is necessary to prevent an instability where an f-string contains a -/// multiline expression and the f-string fits on the line, but only when it's -/// surrounded by parentheses. +/// This is just a wrapper around [`FormatFString`](crate::other::f_string::FormatFString) while +/// considering a special case when the f-string is at an assignment statement's value position. +/// This is necessary to prevent an instability where an f-string contains a multiline expression +/// and the f-string fits on the line, but only when it's surrounded by parentheses. /// /// ```python /// aaaaaaaaaaaaaaaaaa = f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{ diff --git a/crates/ruff_python_formatter/src/statement/stmt_with.rs b/crates/ruff_python_formatter/src/statement/stmt_with.rs index 5cfe7952a5..4e2c6bc876 100644 --- a/crates/ruff_python_formatter/src/statement/stmt_with.rs +++ b/crates/ruff_python_formatter/src/statement/stmt_with.rs @@ -177,8 +177,10 @@ enum WithItemsLayout<'a> { /// ... /// ``` /// - /// In this case, use [`maybe_parenthesize_expression`](crate::expression::maybe_parenthesize_expression) to format the context expression - /// to get the exact same formatting as when formatting an expression in any other clause header. + /// In this case, use + /// [`maybe_parenthesize_expression`](crate::expression::maybe_parenthesize_expression) to + /// format the context expression to get the exact same formatting as when formatting an + /// expression in any other clause header. /// /// Only used for Python 3.9+ /// diff --git a/crates/ruff_python_formatter/src/string/normalize.rs b/crates/ruff_python_formatter/src/string/normalize.rs index 2ed4acb0f1..1500737950 100644 --- a/crates/ruff_python_formatter/src/string/normalize.rs +++ b/crates/ruff_python_formatter/src/string/normalize.rs @@ -38,8 +38,9 @@ impl<'a, 'src> StringNormalizer<'a, 'src> { /// it can't because the string contains the preferred quotes OR /// it leads to more escaping. /// - /// Note: If you add more cases here where we return `QuoteStyle::Preserve`, - /// make sure to also add them to [`FormatImplicitConcatenatedStringFlat::new`](crate::string::implicit::FormatImplicitConcatenatedStringFlat::new). + /// Note: If you add more cases here where we return `QuoteStyle::Preserve`, make sure to also + /// add them to + /// [`FormatImplicitConcatenatedStringFlat::new`](crate::string::implicit::FormatImplicitConcatenatedStringFlat::new). pub(super) fn preferred_quote_style(&self, string: StringLikePart) -> QuoteStyle { let preferred_quote_style = self .preferred_quote_style diff --git a/crates/ruff_python_formatter/src/verbatim.rs b/crates/ruff_python_formatter/src/verbatim.rs index 751b74b174..3dc78a92b7 100644 --- a/crates/ruff_python_formatter/src/verbatim.rs +++ b/crates/ruff_python_formatter/src/verbatim.rs @@ -679,8 +679,9 @@ impl Indentation { /// Returns `true` for a space or tab character. /// -/// This is different than [`is_python_whitespace`](ruff_python_trivia::is_python_whitespace) in that it returns `false` for a form feed character. -/// Form feed characters are excluded because they should be preserved in the suppressed output. +/// This is different than [`is_python_whitespace`](ruff_python_trivia::is_python_whitespace) in +/// that it returns `false` for a form feed character. Form feed characters are excluded because +/// they should be preserved in the suppressed output. const fn is_indent_whitespace(c: char) -> bool { matches!(c, ' ' | '\t') }