refactor(formatter): simplify the use of FormatSeparatedIter

Author: Dunqing

crates/oxc_formatter/src/formatter/formatter.rs

@@ -131,7 +131,7 @@ impl<'buf, 'ast> Formatter<'buf, 'ast> {
         joiner: Joiner,
     ) -> JoinBuilder<'fmt, 'buf, 'ast, Joiner>
     where
-        Joiner: Format<'ast> + Copy,
+        Joiner: Format<'ast>,
     {
         JoinBuilder::with_separator(self, joiner)
     }

crates/oxc_formatter/src/write/array_element_list.rs

@@ -46,18 +46,17 @@ 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 (element, formatted) in self.elements.iter().zip(
-                    FormatSeparatedIter::new(self.elements.iter(), ",")
-                        .with_trailing_separator(trailing_separator)
-                        .with_group_id(self.group_id),
-                ) {
+                for (formatted) 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(element.span(), f) > 1 {
+                            if get_lines_before(formatted.element.span(), f) > 1 {
                                 write!(f, empty_line())
                             } else if f
                                 .comments()
-                                .has_leading_own_line_comments(element.span().start)
+                                .has_leading_own_line_comments(formatted.element.span().start)
                             {
                                 write!(f, hard_line_break())
                             } else {

crates/oxc_formatter/src/write/assignment_pattern_property_list.rs

@@ -14,6 +14,15 @@ enum AssignmentTargetPropertyListNode<'a, 'b> {
     Rest(&'b AstNode<'a, AssignmentTargetRest<'a>>),
 }
 
+impl AssignmentTargetPropertyListNode<'_, '_> {
+    pub fn span(&self) -> Span {
+        match self {
+            AssignmentTargetPropertyListNode::Property(property) => property.span(),
+            AssignmentTargetPropertyListNode::Rest(rest) => rest.span(),
+        }
+    }
+}
+
 impl<'a> Format<'a> for AssignmentTargetPropertyListNode<'a, '_> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         match self {
@@ -70,13 +79,11 @@ impl<'a> Format<'a> for AssignmentTargetPropertyList<'a, '_> {
             },
             ",",
         )
-        .with_trailing_separator(trailing_separator)
-        .zip(
-            self.properties.as_ref().iter().map(GetSpan::span).chain(self.rest.map(GetSpan::span)),
-        );
+        .with_trailing_separator(trailing_separator);
+
         let mut join = f.join_nodes_with_soft_line();
-        for (entry, span) in entries {
-            join.entry(span, &entry);
+        for entry in entries {
+            join.entry(entry.element.span(), &entry);
         }
 
         join.finish()

crates/oxc_formatter/src/write/binding_property_list.rs

@@ -22,6 +22,15 @@ enum BindingPropertyListNode<'a, 'b> {
     Rest(&'b AstNode<'a, BindingRestElement<'a>>),
 }
 
+impl BindingPropertyListNode<'_, '_> {
+    pub fn span(&self) -> Span {
+        match self {
+            BindingPropertyListNode::Property(property) => property.span,
+            BindingPropertyListNode::Rest(rest) => rest.span,
+        }
+    }
+}
+
 impl<'a> Format<'a> for BindingPropertyListNode<'a, '_> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         match self {
@@ -70,12 +79,11 @@ impl<'a> Format<'a> for BindingPropertyList<'a, '_> {
             BindingPropertyListIter { properties: self.properties.iter(), rest: self.rest },
             ",",
         )
-        .with_trailing_separator(trailing_separator)
-        .zip(self.properties.iter().map(|p| p.span).chain(self.rest.map(|r| r.span)));
+        .with_trailing_separator(trailing_separator);
 
         let mut join = f.join_nodes_with_soft_line();
-        for (entry, span) in entries {
-            join.entry(span, &entry);
+        for entry in entries {
+            join.entry(entry.element.span(), &entry);
         }
 
         join.finish()

crates/oxc_formatter/src/write/mod.rs

@@ -197,10 +197,10 @@ impl<'a> Format<'a> for AstNode<'a, Vec<'a, ObjectPropertyKind<'a>>> {
         let trailing_separator = FormatTrailingCommas::ES5.trailing_separator(f.options());
         let source_text = f.context().source_text();
         let mut join = f.join_nodes_with_soft_line();
-        for (element, formatted) in self.iter().zip(
-            FormatSeparatedIter::new(self.iter(), ",").with_trailing_separator(trailing_separator),
-        ) {
-            join.entry(element.span(), &formatted);
+        for formatted in
+            FormatSeparatedIter::new(self.iter(), ",").with_trailing_separator(trailing_separator)
+        {
+            join.entry(formatted.element.span(), &formatted);
         }
         join.finish()
     }
@@ -1649,14 +1649,12 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSEnumBody<'a>> {
 impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSEnumMember<'a>>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         let trailing_separator = FormatTrailingCommas::ES5.trailing_separator(f.options());
-        let source_text = f.source_text();
         let mut join = f.join_nodes_with_soft_line();
-        for (element, formatted) in self.iter().zip(
-            FormatSeparatedIter::new(self.iter(), ",")
-                .with_trailing_separator(trailing_separator)
-                .nodes_grouped(),
-        ) {
-            join.entry(element.span(), &formatted);
+        for formatted in FormatSeparatedIter::new(self.iter(), ",")
+            .with_trailing_separator(trailing_separator)
+            .nodes_grouped()
+        {
+            join.entry(formatted.element.span(), &formatted);
         }
         join.finish()
     }
@@ -2190,7 +2188,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSIndexSignatureName<'a>> {
 
 impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSInterfaceHeritage<'a>>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        f.join_with(&soft_line_break_or_space())
+        f.join_with(soft_line_break_or_space())
             .entries(
                 FormatSeparatedIter::new(self.iter(), ",")
                     .with_trailing_separator(TrailingSeparator::Disallowed),

crates/oxc_formatter/src/write/parameter_list.rs

@@ -121,11 +121,11 @@ impl<'a> Format<'a> for ParameterList<'a, '_> {
                 } else {
                     f.join_nodes_with_soft_line()
                 };
-                let entries = FormatSeparatedIter::new(FormalParametersIter::from(self.list), ",")
-                    .with_trailing_separator(trailing_separator)
-                    .zip(FormalParametersIter::from(self.list));
-                for (formatted, param) in entries {
-                    joiner.entry(param.span(), &formatted);
+                for formatted in
+                    FormatSeparatedIter::new(FormalParametersIter::from(self.list), ",")
+                        .with_trailing_separator(trailing_separator)
+                {
+                    joiner.entry(formatted.element.span(), &formatted);
                 }
                 joiner.finish()
             }

crates/oxc_formatter/src/write/type_parameters.rs

@@ -31,7 +31,7 @@ impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSTypeParameter<'a>>> {
             FormatTrailingCommas::ES5.trailing_separator(f.options())
         };
 
-        f.join_with(&soft_line_break_or_space())
+        f.join_with(soft_line_break_or_space())
             .entries(
                 FormatSeparatedIter::new(self.iter(), ",")
                     .with_trailing_separator(trailing_separator),

crates/oxc_formatter/src/write/variable_declaration.rs

@@ -62,32 +62,26 @@ impl<'a> Format<'a> for AstNode<'a, Vec<'a, VariableDeclarator<'a>>> {
             }
         });
 
-        let mut declarators = self.iter().zip(
-            FormatSeparatedIter::new(self.iter(), ",")
-                .with_trailing_separator(TrailingSeparator::Disallowed),
-        );
+        let mut declarators = FormatSeparatedIter::new(self.iter(), ",")
+            .with_trailing_separator(TrailingSeparator::Disallowed);
 
-        let (first_declarator_span, format_first_declarator) = match declarators.next() {
-            Some((decl, format_first_declarator)) => (decl.span(), format_first_declarator),
-            None => return Err(FormatError::SyntaxError),
-        };
+        // `VariableDeclaration` always has at least one declarator.
+        let first_declarator = declarators.next().unwrap();
 
-        if length == 1 && !f.comments().has_comments_before(first_declarator_span.start) {
-            return write!(f, format_first_declarator);
+        if length == 1 && !f.comments().has_comments_before(first_declarator.element.span().start) {
+            return write!(f, first_declarator);
         }
 
         write!(
             f,
             indent(&format_once(|f| {
-                write!(f, format_first_declarator)?;
+                write!(f, first_declarator)?;
 
                 if length > 1 {
                     write!(f, format_separator)?;
                 }
 
-                f.join_with(&format_separator)
-                    .entries(declarators.map(|(_, format)| format))
-                    .finish()
+                f.join_with(format_separator).entries(declarators).finish()
             }))
         )
     }