Accept any Into<AnyNodeRef> as Comments arguments (#5205)

crates/ruff_python_formatter/src/comments/mod.rs

@@ -260,76 +260,109 @@ impl<'a> Comments<'a> {
     }
 
     #[inline]
-    pub(crate) fn has_comments(&self, node: AnyNodeRef) -> bool {
+    pub(crate) fn has_comments<T>(&self, node: T) -> bool
-        self.data.comments.has(&NodeRefEqualityKey::from_ref(node))
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
+        self.data
+            .comments
+            .has(&NodeRefEqualityKey::from_ref(node.into()))
     }
 
     /// Returns `true` if the given `node` has any [leading comments](self#leading-comments).
     #[inline]
-    pub(crate) fn has_leading_comments(&self, node: AnyNodeRef) -> bool {
+    pub(crate) fn has_leading_comments<T>(&self, node: T) -> bool
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         !self.leading_comments(node).is_empty()
     }
 
     /// Returns the `node`'s [leading comments](self#leading-comments).
     #[inline]
-    pub(crate) fn leading_comments(&self, node: AnyNodeRef<'a>) -> &[SourceComment] {
+    pub(crate) fn leading_comments<T>(&self, node: T) -> &[SourceComment]
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         self.data
             .comments
-            .leading(&NodeRefEqualityKey::from_ref(node))
+            .leading(&NodeRefEqualityKey::from_ref(node.into()))
     }
 
     /// Returns `true` if node has any [dangling comments](self#dangling-comments).
-    pub(crate) fn has_dangling_comments(&self, node: AnyNodeRef<'a>) -> bool {
+    pub(crate) fn has_dangling_comments<T>(&self, node: T) -> bool
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         !self.dangling_comments(node).is_empty()
     }
 
     /// Returns the [dangling comments](self#dangling-comments) of `node`
-    pub(crate) fn dangling_comments(&self, node: AnyNodeRef<'a>) -> &[SourceComment] {
+    pub(crate) fn dangling_comments<T>(&self, node: T) -> &[SourceComment]
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         self.data
             .comments
-            .dangling(&NodeRefEqualityKey::from_ref(node))
+            .dangling(&NodeRefEqualityKey::from_ref(node.into()))
     }
 
     /// Returns the `node`'s [trailing comments](self#trailing-comments).
     #[inline]
-    pub(crate) fn trailing_comments(&self, node: AnyNodeRef<'a>) -> &[SourceComment] {
+    pub(crate) fn trailing_comments<T>(&self, node: T) -> &[SourceComment]
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         self.data
             .comments
-            .trailing(&NodeRefEqualityKey::from_ref(node))
+            .trailing(&NodeRefEqualityKey::from_ref(node.into()))
     }
 
     /// Returns `true` if the given `node` has any [trailing comments](self#trailing-comments).
     #[inline]
-    pub(crate) fn has_trailing_comments(&self, node: AnyNodeRef) -> bool {
+    pub(crate) fn has_trailing_comments<T>(&self, node: T) -> bool
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         !self.trailing_comments(node).is_empty()
     }
 
     /// Returns `true` if the given `node` has any [trailing own line comments](self#trailing-comments).
     #[inline]
-    pub(crate) fn has_trailing_own_line_comments(&self, node: AnyNodeRef) -> bool {
+    pub(crate) fn has_trailing_own_line_comments<T>(&self, node: T) -> bool
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         self.trailing_comments(node)
             .iter()
             .any(|comment| comment.position().is_own_line())
     }
 
     /// Returns an iterator over the [leading](self#leading-comments) and [trailing comments](self#trailing-comments) of `node`.
-    pub(crate) fn leading_trailing_comments(
+    pub(crate) fn leading_trailing_comments<T>(
         &self,
-        node: AnyNodeRef<'a>,
+        node: T,
-    ) -> impl Iterator<Item = &SourceComment> {
+    ) -> impl Iterator<Item = &SourceComment>
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
+        let node = node.into();
         self.leading_comments(node)
             .iter()
             .chain(self.trailing_comments(node).iter())
     }
 
     /// Returns an iterator over the [leading](self#leading-comments), [dangling](self#dangling-comments), and [trailing](self#trailing) comments of `node`.
-    pub(crate) fn leading_dangling_trailing_comments(
+    pub(crate) fn leading_dangling_trailing_comments<T>(
         &self,
-        node: AnyNodeRef<'a>,
+        node: T,
-    ) -> impl Iterator<Item = &SourceComment> {
+    ) -> impl Iterator<Item = &SourceComment>
+    where
+        T: Into<AnyNodeRef<'a>>,
+    {
         self.data
             .comments
-            .parts(&NodeRefEqualityKey::from_ref(node))
+            .parts(&NodeRefEqualityKey::from_ref(node.into()))
     }
 
     #[inline(always)]

crates/ruff_python_formatter/src/expression/expr_bin_op.rs

@@ -91,7 +91,7 @@ impl FormatNodeRule<ExprBinOp> for FormatExprBinOp {
             )?;
 
             // Format the operator on its own line if the right side has any leading comments.
-            if comments.has_leading_comments(right.as_ref().into()) {
+            if comments.has_leading_comments(right.as_ref()) {
                 write!(f, [hard_line_break()])?;
             } else if needs_space {
                 write!(f, [space()])?;

crates/ruff_python_formatter/src/expression/expr_dict.rs

@@ -35,7 +35,7 @@ impl Format<PyFormatContext<'_>> for KeyValuePair<'_> {
             )
         } else {
             let comments = f.context().comments().clone();
-            let leading_value_comments = comments.leading_comments(self.value.into());
+            let leading_value_comments = comments.leading_comments(self.value);
             write!(
                 f,
                 [

crates/ruff_python_formatter/src/expression/expr_list.rs

@@ -19,7 +19,7 @@ impl FormatNodeRule<ExprList> for FormatExprList {
         } = item;
 
         let comments = f.context().comments().clone();
-        let dangling = comments.dangling_comments(item.into());
+        let dangling = comments.dangling_comments(item);
 
         // The empty list is special because there can be dangling comments, and they can be in two
         // positions:

crates/ruff_python_formatter/src/lib.rs

@@ -1,3 +1,7 @@
+use crate::comments::{
+    dangling_node_comments, leading_node_comments, trailing_node_comments, Comments,
+};
+use crate::context::PyFormatContext;
 use anyhow::{anyhow, Context, Result};
 use ruff_formatter::prelude::*;
 use ruff_formatter::{format, write};
@@ -10,11 +14,6 @@ use rustpython_parser::lexer::lex;
 use rustpython_parser::{parse_tokens, Mode};
 use std::borrow::Cow;
 
-use crate::comments::{
-    dangling_node_comments, leading_node_comments, trailing_node_comments, Comments,
-};
-use crate::context::PyFormatContext;
-
 pub(crate) mod builders;
 pub mod cli;
 mod comments;
@@ -437,9 +436,10 @@ def with_leading_comment(): ...
         // Uncomment the `dbg` to print the IR.
         // Use `dbg_write!(f, []) instead of `write!(f, [])` in your formatting code to print some IR
         // inside of a `Format` implementation
-        // dbg!(formatted
+        // use ruff_formatter::FormatContext;
+        // formatted
         //     .document()
-        //     .display(formatted.context().source_code()));
+        //     .display(formatted.context().source_code());
 
         // dbg!(formatted
         //     .context()

crates/ruff_python_formatter/src/prelude.rs

@@ -1,7 +1,7 @@
 #[allow(unused_imports)]
 pub(crate) use crate::{
-    builders::PyFormatterExtensions, AsFormat, FormattedIterExt as _, IntoFormat, PyFormatContext,
+    builders::PyFormatterExtensions, AsFormat, FormatNodeRule, FormattedIterExt as _, IntoFormat,
-    PyFormatter,
+    PyFormatContext, PyFormatter,
 };
 #[allow(unused_imports)]
 pub(crate) use ruff_formatter::prelude::*;

crates/ruff_python_formatter/src/statement/stmt_function_def.rs

@@ -37,7 +37,7 @@ impl FormatRule<AnyFunctionDefinition<'_>, PyFormatContext<'_>> for FormatAnyFun
     ) -> FormatResult<()> {
         let comments = f.context().comments().clone();
 
-        let dangling_comments = comments.dangling_comments(item.into());
+        let dangling_comments = comments.dangling_comments(item);
         let trailing_definition_comments_start =
             dangling_comments.partition_point(|comment| comment.position().is_own_line());
 

crates/ruff_python_formatter/src/statement/stmt_if.rs

@@ -23,7 +23,7 @@ impl FormatNodeRule<StmtIf> for FormatStmtIf {
             } = current_statement;
 
             let first_statement = body.first().ok_or(FormatError::SyntaxError)?;
-            let trailing = comments.dangling_comments(current_statement.into());
+            let trailing = comments.dangling_comments(current_statement);
 
             let trailing_if_comments_end = trailing
                 .partition_point(|comment| comment.slice().start() < first_statement.start());
@@ -32,7 +32,7 @@ impl FormatNodeRule<StmtIf> for FormatStmtIf {
                 trailing.split_at(trailing_if_comments_end);
 
             if current.is_elif() {
-                let elif_leading = comments.leading_comments(current_statement.into());
+                let elif_leading = comments.leading_comments(current_statement);
                 // Manually format the leading comments because the formatting bypasses `NodeRule::fmt`
                 write!(
                     f,

crates/ruff_python_formatter/src/statement/suite.rs

@@ -96,13 +96,12 @@ impl FormatRule<Suite, PyFormatContext<'_>> for FormatSuite {
                 // the leading comment. This is why the suite handling counts the lines before the
                 // start of the next statement or before the first leading comments for compound statements.
                 let separator = format_with(|f| {
-                    let start = if let Some(first_leading) =
+                    let start =
-                        comments.leading_comments(statement.into()).first()
+                        if let Some(first_leading) = comments.leading_comments(statement).first() {
-                    {
+                            first_leading.slice().start()
-                        first_leading.slice().start()
+                        } else {
-                    } else {
+                            statement.start()
-                        statement.start()
+                        };
-                    };
 
                     match lines_before(start, source) {
                         0 | 1 => hard_line_break().fmt(f),