refactor(formatter): simplify usages of iter + FormatSeparatedIter

Author: Dunqing

crates/oxc_formatter/src/formatter/builders.rs

@@ -19,8 +19,9 @@ use super::{
         tag::{DedentMode, GroupMode, LabelId},
         *,
     },
+    separated::FormatSeparatedIter,
 };
-use crate::write;
+use crate::{TrailingSeparator, write};
 
 /// A line break that only gets printed if the enclosing `Group` doesn't fit on a single line.
 ///
@@ -2390,6 +2391,26 @@ where
         self
     }
 
+    pub fn entries_with_trailing_separator<F, I>(
+        &mut self,
+        entries: I,
+        separator: &'static str,
+        trailing_separator: TrailingSeparator,
+    ) -> &mut Self
+    where
+        F: Format<'ast> + GetSpan,
+        I: IntoIterator<Item = F>,
+    {
+        let iter = FormatSeparatedIter::new(entries.into_iter(), separator)
+            .with_trailing_separator(trailing_separator);
+
+        for entry in iter {
+            self.entry(&entry);
+        }
+
+        self
+    }
+
     /// Finishes the output and returns any error encountered.
     pub fn finish(&mut self) -> FormatResult<()> {
         self.result
@@ -2443,14 +2464,33 @@ where
     pub fn entries<'a, F, I>(&mut self, entries: I) -> &mut Self
     where
         F: Format<'ast> + GetSpan + 'a,
-        I: IntoIterator<Item = &'a F>,
+        I: IntoIterator<Item = F>,
     {
         for content in entries {
             self.entry(content.span(), &content);
         }
         self
     }
 
+    pub fn entries_with_trailing_separator<'a, F, I>(
+        &mut self,
+        entries: I,
+        separator: &'static str,
+        trailing_separator: TrailingSeparator,
+    ) -> &mut Self
+    where
+        F: Format<'ast> + GetSpan + 'a,
+        I: IntoIterator<Item = F>,
+    {
+        let iter = FormatSeparatedIter::new(entries.into_iter(), separator)
+            .with_trailing_separator(trailing_separator);
+
+        for content in iter {
+            self.entry(content.span(), &content);
+        }
+        self
+    }
+
     pub fn finish(&mut self) -> FormatResult<()> {
         self.result
     }

crates/oxc_formatter/src/formatter/separated.rs

@@ -1,3 +1,5 @@
+use oxc_span::{GetSpan, Span};
+
 use crate::{
     formatter::{
         Format, FormatResult, Formatter,
@@ -10,16 +12,22 @@ use super::GroupId;
 
 /// Formats a single element inside a separated list.
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct FormatSeparatedElement<E> {
+pub struct FormatSeparatedElement<E: GetSpan> {
     // Public this field to make it easier to get the element span from `FormatSeparatedElement`.
-    pub element: E,
+    element: E,
     is_last: bool,
     /// The separator to write if the element has no separator yet.
     separator: &'static str,
     options: FormatSeparatedOptions,
 }
 
-impl<'a, E: Format<'a>> Format<'a> for FormatSeparatedElement<E> {
+impl<T: GetSpan> GetSpan for FormatSeparatedElement<T> {
+    fn span(&self) -> Span {
+        self.element.span()
+    }
+}
+
+impl<'a, E: Format<'a> + GetSpan> Format<'a> for FormatSeparatedElement<E> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         if self.options.nodes_grouped {
             group(&self.element).fmt(f)?;
@@ -42,14 +50,14 @@ impl<'a, E: Format<'a>> Format<'a> for FormatSeparatedElement<E> {
 
 /// Iterator for formatting separated elements. Prints the separator between each element and
 /// inserts a trailing separator if necessary
-pub struct FormatSeparatedIter<I, E> {
+pub struct FormatSeparatedIter<I, E: GetSpan> {
     next: Option<E>,
     inner: I,
     separator: &'static str,
     options: FormatSeparatedOptions,
 }
 
-impl<I, E> FormatSeparatedIter<I, E>
+impl<I, E: GetSpan> FormatSeparatedIter<I, E>
 where
     I: Iterator<Item = E>,
 {
@@ -74,7 +82,7 @@ where
     }
 }
 
-impl<I, E> Iterator for FormatSeparatedIter<I, E>
+impl<I, E: GetSpan> Iterator for FormatSeparatedIter<I, E>
 where
     I: Iterator<Item = E>,
 {

crates/oxc_formatter/src/generated/ast_nodes.rs

@@ -3110,6 +3110,11 @@ pub struct AstNode<'a, T> {
     pub(super) allocator: &'a Allocator,
     pub(super) following_node: Option<SiblingNode<'a>>,
 }
+impl<T: GetSpan> GetSpan for &AstNode<'_, T> {
+    fn span(&self) -> Span {
+        self.inner.span()
+    }
+}
 
 impl<'a, T: fmt::Debug> fmt::Debug for AstNode<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

crates/oxc_formatter/src/utils/member_chain/mod.rs

@@ -193,12 +193,7 @@ impl<'a> Format<'a> for MemberChain<'a, '_> {
         let has_comments = self.has_comments(f);
 
         let format_one_line = format_with(|f| {
-            let mut joiner = f.join();
-
-            joiner.entry(&self.head);
-            joiner.entries(self.tail.iter());
-
-            joiner.finish()
+            f.join().entries(iter::once(&self.head).chain(self.tail.iter())).finish()
         });
 
         if self.tail.len() <= 1 && !has_comments {

crates/oxc_formatter/src/write/array_element_list.rs

@@ -46,24 +46,24 @@ impl<'a> Format<'a> for ArrayElementList<'a, '_> {
                 let mut filler = f.fill();
 
                 // Using format_separated is valid in this case as can_print_fill does not allow holes
-                for (formatted) in FormatSeparatedIter::new(self.elements.iter(), ",")
+                for element in FormatSeparatedIter::new(self.elements.iter(), ",")
                     .with_trailing_separator(trailing_separator)
                     .with_group_id(self.group_id)
                 {
                     filler.entry(
                         &format_once(|f| {
-                            if get_lines_before(formatted.element.span(), f) > 1 {
+                            if get_lines_before(element.span(), f) > 1 {
                                 write!(f, empty_line())
                             } else if f
                                 .comments()
-                                .has_leading_own_line_comments(formatted.element.span().start)
+                                .has_leading_own_line_comments(element.span().start)
                             {
                                 write!(f, hard_line_break())
                             } else {
                                 write!(f, soft_line_break_or_space())
                             }
                         }),
-                        &formatted,
+                        &element,
                     );
                 }
 

crates/oxc_formatter/src/write/assignment_pattern_property_list.rs

@@ -14,8 +14,8 @@ enum AssignmentTargetPropertyListNode<'a, 'b> {
     Rest(&'b AstNode<'a, AssignmentTargetRest<'a>>),
 }
 
-impl AssignmentTargetPropertyListNode<'_, '_> {
-    pub fn span(&self) -> Span {
+impl GetSpan for AssignmentTargetPropertyListNode<'_, '_> {
+    fn span(&self) -> Span {
         match self {
             AssignmentTargetPropertyListNode::Property(property) => property.span(),
             AssignmentTargetPropertyListNode::Rest(rest) => rest.span(),
@@ -71,21 +71,15 @@ impl<'a> Format<'a> for AssignmentTargetPropertyList<'a, '_> {
         } else {
             FormatTrailingCommas::ES5.trailing_separator(f.options())
         };
-        let source_text = f.source_text();
-        let entries = FormatSeparatedIter::new(
-            AssignmentTargetPropertyListIter {
-                properties: self.properties.iter(),
-                rest: self.rest,
-            },
-            ",",
-        )
-        .with_trailing_separator(trailing_separator);
-
-        let mut join = f.join_nodes_with_soft_line();
-        for entry in entries {
-            join.entry(entry.element.span(), &entry);
-        }
-
-        join.finish()
+        f.join_nodes_with_soft_line()
+            .entries_with_trailing_separator(
+                AssignmentTargetPropertyListIter {
+                    properties: self.properties.iter(),
+                    rest: self.rest,
+                },
+                ",",
+                trailing_separator,
+            )
+            .finish()
     }
 }

crates/oxc_formatter/src/write/binding_property_list.rs

@@ -1,5 +1,6 @@
 use oxc_allocator::{Box, Vec};
 use oxc_ast::ast::*;
+use oxc_span::GetSpan;
 
 use crate::{
     formatter::{
@@ -22,8 +23,8 @@ enum BindingPropertyListNode<'a, 'b> {
     Rest(&'b AstNode<'a, BindingRestElement<'a>>),
 }
 
-impl BindingPropertyListNode<'_, '_> {
-    pub fn span(&self) -> Span {
+impl GetSpan for BindingPropertyListNode<'_, '_> {
+    fn span(&self) -> Span {
         match self {
             BindingPropertyListNode::Property(property) => property.span,
             BindingPropertyListNode::Rest(rest) => rest.span,
@@ -75,17 +76,13 @@ impl<'a> Format<'a> for BindingPropertyList<'a, '_> {
             FormatTrailingCommas::ES5.trailing_separator(f.options())
         };
         let source_text = f.source_text();
-        let entries = FormatSeparatedIter::new(
-            BindingPropertyListIter { properties: self.properties.iter(), rest: self.rest },
-            ",",
-        )
-        .with_trailing_separator(trailing_separator);
 
-        let mut join = f.join_nodes_with_soft_line();
-        for entry in entries {
-            join.entry(entry.element.span(), &entry);
-        }
-
-        join.finish()
+        f.join_nodes_with_soft_line()
+            .entries_with_trailing_separator(
+                BindingPropertyListIter { properties: self.properties.iter(), rest: self.rest },
+                ",",
+                trailing_separator,
+            )
+            .finish()
     }
 }

crates/oxc_formatter/src/write/call_arguments.rs

@@ -86,9 +86,10 @@ impl<'a> Format<'a> for AstNode<'a, ArenaVec<'a, Argument<'a>>> {
                     l_paren_token,
                     format_with(|f| {
                         f.join_with(space())
-                            .entries(
-                                FormatSeparatedIter::new(self.iter(), ",")
-                                    .with_trailing_separator(TrailingSeparator::Omit),
+                            .entries_with_trailing_separator(
+                                self.iter(),
+                                ",",
+                                TrailingSeparator::Omit,
                             )
                             .finish()
                     }),

crates/oxc_formatter/src/write/class.rs

@@ -201,9 +201,10 @@ impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSClassImplements<'a>>> {
                     format_once(|f| {
                         // the grouping will be applied by the parent
                         f.join_with(&soft_line_break_or_space())
-                            .entries(
-                                FormatSeparatedIter::new(self.iter(), ",")
-                                    .with_trailing_separator(TrailingSeparator::Disallowed),
+                            .entries_with_trailing_separator(
+                                self.iter(),
+                                ",",
+                                TrailingSeparator::Disallowed,
                             )
                             .finish()
                     })

crates/oxc_formatter/src/write/export_declarations.rs

@@ -139,26 +139,27 @@ impl<'a> FormatWrite<'a> for AstNode<'a, ExportNamedDeclaration<'a>> {
 impl<'a> Format<'a> for AstNode<'a, Vec<'a, ExportSpecifier<'a>>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         let trailing_separator = FormatTrailingCommas::ES5.trailing_separator(f.options());
-        let mut joiner = f.join_with(soft_line_break_or_space());
-        for specifier in
-            FormatSeparatedIter::new(self.iter(), ",").with_trailing_separator(trailing_separator)
-        {
-            joiner.entry(&format_once(|f| {
-                // Should add empty line before the specifier if there are comments before it.
-                let comments =
-                    f.context().comments().comments_before(specifier.element.span().start);
-                if !comments.is_empty() {
-                    if get_lines_before(comments[0].span, f) > 1 {
-                        write!(f, [empty_line()])?;
-                    }
-                    write!(f, [FormatLeadingComments::Comments(comments)])?;
-                }
-
-                write!(f, specifier)
-            }));
-        }
-
-        joiner.finish()
+        f.join_with(soft_line_break_or_space())
+            .entries(
+                FormatSeparatedIter::new(self.iter(), ",")
+                    .with_trailing_separator(trailing_separator)
+                    .map(|specifier| {
+                        format_once(move |f| {
+                            // Should add empty line before the specifier if there are comments before it.
+                            let comments =
+                                f.context().comments().comments_before(specifier.span().start);
+                            if !comments.is_empty() {
+                                if get_lines_before(comments[0].span, f) > 1 {
+                                    write!(f, [empty_line()])?;
+                                }
+                                write!(f, [FormatLeadingComments::Comments(comments)])?;
+                            }
+
+                            write!(f, specifier)
+                        })
+                    }),
+            )
+            .finish()
     }
 }