fix: review feedback

Author: dyc3

crates/biome_yaml_formatter/src/yaml/auxiliary/block_map_implicit_entry.rs

@@ -37,7 +37,7 @@ impl FormatNodeRule<YamlBlockMapImplicitEntry> for FormatYamlBlockMapImplicitEnt
             }
 
             if value.is_flow_collection() {
-                // Like Prettier: a collection that a comment forces to break
+                // A collection that a comment forces to break
                 // stays on the key's line, while one that only breaks because
                 // it doesn't fit moves as a whole to its own indented line.
                 // Both keep the collection's entries and closing bracket

crates/biome_yaml_formatter/src/yaml/auxiliary/flow_map_explicit_entry.rs

@@ -1,7 +1,7 @@
-use super::flow_map_implicit_entry::format_implicit_entry_body;
+use super::flow_map_implicit_entry::FormatImplicitEntryBody;
 use crate::prelude::*;
 use biome_formatter::trivia::format_dangling_comments;
-use biome_formatter::write;
+use biome_formatter::{format_args, write};
 use biome_rowan::AstNode;
 use biome_yaml_syntax::{
     AnyYamlFlowNode, AnyYamlMappingImplicitKey, YamlFlowMapExplicitEntry,
@@ -31,20 +31,43 @@ impl FormatNodeRule<YamlFlowMapExplicitEntry> for FormatYamlFlowMapExplicitEntry
 
         // The explicit form is required when the key is a flow collection
         // that may break across multiple lines, or when a comment sits
-        // between the key and the `:`. Everywhere else Prettier prints the
-        // entry in the implicit `key: value` form
+        // between the key and the `:`:
+        //
+        // ```yaml
+        // {
+        //   ? [a, b]
+        //   : v,
+        //   ? key
+        //   # comment
+        //   : v,
+        // }
+        // ```
+        //
+        // Otherwise print the entry in the implicit `key: value` form:
+        //
+        // ```yaml
+        // { ? key : v }
+        // ```
+        //
+        // becomes
+        //
+        // ```yaml
+        // { key: v }
+        // ```
         let keep_explicit = colon_token.is_some()
             && (has_dangling_comments
                 || (value.is_some() && key.as_ref().is_some_and(|key| key.is_flow_collection())));
 
         if let (Some(colon_token), true) = (&colon_token, keep_explicit) {
-            format_explicit_pair(
-                Some(&question_mark_token),
-                &key,
-                colon_token,
-                &value,
-                has_dangling_comments.then(|| node.syntax()),
+            write!(
                 f,
+                [FormatExplicitPair {
+                    question_mark_token: &question_mark_token,
+                    key: &key,
+                    colon_token,
+                    value: &value,
+                    dangling_comments_of: has_dangling_comments.then(|| node.syntax()),
+                }]
             )
         } else if !in_flow_mapping {
             // Inside a flow sequence, `? key` is a compact single-pair
@@ -61,24 +84,32 @@ impl FormatNodeRule<YamlFlowMapExplicitEntry> for FormatYamlFlowMapExplicitEntry
                         f,
                         [align(
                             "  ",
-                            &format_with(|f| {
-                                format_implicit_entry_body(&key, &colon_token, &value, false, f)
-                            })
+                            &FormatImplicitEntryBody {
+                                key: &key,
+                                colon_token: &colon_token,
+                                value: &value,
+                                in_flow_mapping: false
+                            }
                         )]
                     )
                 }))]
             )
         } else if key.is_none() && colon_token.is_none() && value.is_none() {
             // A lone `?` denotes an entry with an empty key and an empty
-            // value, which Prettier prints as a lone `:`
+            // value, which we normalize to `:`.
             write!(f, [format_replaced(&question_mark_token, &text(":", None))])
         } else {
             write!(
                 f,
-                [group(&format_with(|f| {
-                    write!(f, [format_removed(&question_mark_token)])?;
-                    format_implicit_entry_body(&key, &colon_token, &value, true, f)
-                }))]
+                [group(&format_args![
+                    format_removed(&question_mark_token),
+                    FormatImplicitEntryBody {
+                        key: &key,
+                        colon_token: &colon_token,
+                        value: &value,
+                        in_flow_mapping: true
+                    }
+                ])]
             )
         }
     }
@@ -88,7 +119,7 @@ impl FormatNodeRule<YamlFlowMapExplicitEntry> for FormatYamlFlowMapExplicitEntry
         _: &YamlFlowMapExplicitEntry,
         _: &mut YamlFormatter,
     ) -> FormatResult<()> {
-        // Printed in `fmt_fields` between the key and the `:`
+        // Printed in `FormatExplicitPair` between the key and the `:`
         Ok(())
     }
 }
@@ -100,31 +131,28 @@ impl FormatNodeRule<YamlFlowMapExplicitEntry> for FormatYamlFlowMapExplicitEntry
 /// : value
 /// ```
 ///
-/// When `question_mark_token` is absent (an implicit entry whose collection
-/// key breaks across multiple lines, where only the explicit form is valid),
-/// a `?` is synthesized, exactly like Prettier does.
-pub(crate) fn format_explicit_pair(
-    question_mark_token: Option<&YamlSyntaxToken>,
-    key: &Option<AnyYamlMappingImplicitKey>,
-    colon_token: &YamlSyntaxToken,
-    value: &Option<AnyYamlFlowNode>,
-    dangling_comments_of: Option<&YamlSyntaxNode>,
-    f: &mut YamlFormatter,
-) -> FormatResult<()> {
-    match question_mark_token {
-        Some(question_mark_token) => write!(f, [question_mark_token.format()])?,
-        None => write!(f, [text("?", None)])?,
-    }
-    if let Some(key) = key {
-        write!(f, [space(), align("  ", &key.format())])?;
-    }
-    write!(f, [hard_line_break()])?;
-    if let Some(node) = dangling_comments_of {
-        write!(f, [format_dangling_comments(node), hard_line_break()])?;
-    }
-    write!(f, [colon_token.format()])?;
-    if let Some(value) = value {
-        write!(f, [space(), align("  ", &value.format())])?;
+struct FormatExplicitPair<'a> {
+    question_mark_token: &'a YamlSyntaxToken,
+    key: &'a Option<AnyYamlMappingImplicitKey>,
+    colon_token: &'a YamlSyntaxToken,
+    value: &'a Option<AnyYamlFlowNode>,
+    dangling_comments_of: Option<&'a YamlSyntaxNode>,
+}
+
+impl Format<YamlFormatContext> for FormatExplicitPair<'_> {
+    fn fmt(&self, f: &mut YamlFormatter) -> FormatResult<()> {
+        write!(f, [self.question_mark_token.format()])?;
+        if let Some(key) = self.key {
+            write!(f, [space(), align("  ", &key.format())])?;
+        }
+        write!(f, [hard_line_break()])?;
+        if let Some(node) = self.dangling_comments_of {
+            write!(f, [format_dangling_comments(node), hard_line_break()])?;
+        }
+        write!(f, [self.colon_token.format()])?;
+        if let Some(value) = self.value {
+            write!(f, [space(), align("  ", &value.format())])?;
+        }
+        Ok(())
     }
-    Ok(())
 }