Add partial implementation of can_omit_optional_parentheses

crates/ruff_python_formatter/src/comments/placement.rs

@@ -1215,11 +1215,22 @@ fn handle_expr_if_comment<'a>(
  CommentPlacement::Default(comment)
 }
 
-/// Looks for a token in the range that contains no other tokens.
+/// Looks for a token in the range that contains no other tokens than closing parentheses.
 fn find_only_token_in_range(range: TextRange, locator: &Locator, token_kind: TokenKind) -> Token {
  let mut tokens = SimpleTokenizer::new(locator.contents(), range).skip_trivia();
- let token = tokens.next().expect("Expected a token");
- debug_assert_eq!(token.kind(), token_kind);
+ let token = loop {
+ if let Some(token) = tokens.next() {
+ if token.kind() == token_kind {
+ break token;
+ } else if token.kind() == TokenKind::RParen {
+ // skip over right parens
+ } else {
+ unreachable!("Expected {token_kind:?} but found {token:?})");
+ }
+ } else {
+ unreachable!("Expected a {token_kind:?} token but found none");
+ };
+ };
  debug_assert_eq!(tokens.next(), None);
  token
 }

crates/ruff_python_formatter/src/expression/expr_if_exp.rs

@@ -1,10 +1,11 @@
 use crate::comments::{leading_comments, Comments};
 use crate::expression::parentheses::{
- default_expression_needs_parentheses, NeedsParentheses, Parentheses, Parenthesize,
+ default_expression_needs_parentheses, in_parentheses_only_group, NeedsParentheses, Parentheses,
+ Parenthesize,
 };
-use crate::{AsFormat, FormatNodeRule, PyFormatter};
-use ruff_formatter::prelude::{group, soft_line_break_or_space, space, text};
-use ruff_formatter::{format_args, write, Buffer, FormatResult};
+use crate::prelude::*;
+use crate::FormatNodeRule;
+use ruff_formatter::{format_args, write};
 use rustpython_parser::ast::ExprIfExp;
 
 #[derive(Default)]
@@ -19,12 +20,13 @@ impl FormatNodeRule<ExprIfExp> for FormatExprIfExp {
  orelse,
  } = item;
  let comments = f.context().comments().clone();
+
  // We place `if test` and `else orelse` on a single line, so the `test` and `orelse` leading
  // comments go on the line before the `if` or `else` instead of directly ahead `test` or
  // `orelse`
  write!(
  f,
- [group(&format_args![
+ [in_parentheses_only_group(&format_args![
  body.format(),
  soft_line_break_or_space(),
  leading_comments(comments.leading_comments(test.as_ref())),

crates/ruff_python_formatter/src/expression/expr_subscript.rs

@@ -1,12 +1,16 @@
+use rustpython_parser::ast::ExprSubscript;
+
+use ruff_formatter::{format_args, write};
+use ruff_python_ast::node::AstNode;
+
 use crate::comments::{trailing_comments, Comments};
+use crate::context::NodeLevel;
 use crate::expression::parentheses::{
- default_expression_needs_parentheses, NeedsParentheses, Parentheses, Parenthesize,
+ default_expression_needs_parentheses, in_parentheses_only_group, NeedsParentheses, Parentheses,
+ Parenthesize,
 };
-use crate::{AsFormat, FormatNodeRule, PyFormatter};
-use ruff_formatter::prelude::{group, soft_block_indent, text};
-use ruff_formatter::{format_args, write, Buffer, FormatResult};
-use ruff_python_ast::node::AstNode;
-use rustpython_parser::ast::ExprSubscript;
+use crate::prelude::*;
+use crate::FormatNodeRule;
 
 #[derive(Default)]
 pub struct FormatExprSubscript;
@@ -27,10 +31,20 @@ impl FormatNodeRule<ExprSubscript> for FormatExprSubscript {
  "The subscript expression must have at most a single comment, the one after the bracket"
  );
 
+ if let NodeLevel::Expression(Some(group_id)) = f.context().node_level() {
+ // Enforce the optional parentheses for parenthesized values.
+ f.context_mut().set_node_level(NodeLevel::Expression(None));
+ let result = value.format().fmt(f);
+ f.context_mut()
+ .set_node_level(NodeLevel::Expression(Some(group_id)));
+ result?;
+ } else {
+ value.format().fmt(f)?;
+ }
+
  write!(
  f,
- [group(&format_args![
- value.format(),
+ [in_parentheses_only_group(&format_args![
  text("["),
  trailing_comments(dangling_comments),
  soft_block_indent(&slice.format()),