fix(js_formatter): fix propagate_expand for interned elements with best_fitting

crates/biome_formatter/src/format_element/document.rs

@@ -72,10 +72,43 @@ impl Document {
                             propagate_expands(variant, enclosing, checked_interned);
                         }
 
-                        // Best fitting acts as a boundary
-                        expands = false;
                         enclosing.pop();
-                        continue;
+                        // BestFitting acts as a boundary, meaning there is no need to continue
+                        // processing this element and we can move onto the next. However, we
+                        // _don't_ set `expands = false`, because that ends up negating the
+                        // expansion when processing `Interned` elements.
+                        //
+                        // Only interned lists are affected, because they cache the expansion value
+                        // based on the value of `expands` at the end of iterating the children. If
+                        // a `best_fitting` element occurs after the last expanding element, and we
+                        // end up setting `expands = false` here, then the interned element ends up
+                        // thinking that its content doesn't expand, even though it might. Example:
+                        //   group(1,
+                        //     interned 1 [
+                        //       expand_parent,
+                        //       best_fitting,
+                        //     ]
+                        //   )
+                        //   group(2,
+                        //     [ref interned 1]
+                        //   )
+                        // Here, `group(1)` gets expanded directly by the `expand_parent` element.
+                        // This happens immediately, and then `expands = true` is set. The interned
+                        // element continues processing, and encounters the `best_fitting`. If
+                        // we set `expands = false` there, then the interned element's result ends
+                        // up being `false`, even though it does actually expand. Then, when
+                        // `group(2)` checks for expansion, it looks at the ref to `interned 1`,
+                        // which thinks it doesn't expand, and so `group(2)` stays flat.
+                        //
+                        // By _not_ setting `expands = false`, even though `best_fitting` is a
+                        // boundary for expansion, we ensure that any references to the interned
+                        // element will get the correct value for whether the contained content
+                        // actually expands, regardless of the order of elements within it.
+                        //
+                        // Instead, just returning false here enforces that `best_fitting` doesn't
+                        // think it expands _itself_, but allows other sibling elements to still
+                        // propagate their expansion.
+                        false
                     }
                     FormatElement::StaticText { text } => text.contains('\n'),
                     FormatElement::DynamicText { text, .. } => text.contains('\n'),
@@ -746,6 +779,55 @@ mod tests {
   "]"<END_TAG_WITHOUT_START<Indent>>,
   indent([])
   <START_WITHOUT_END<Indent>>
+]"#
+        );
+    }
+
+    #[test]
+    fn interned_best_fitting_allows_sibling_expand_propagation() {
+        use Tag::*;
+
+        // An interned element containing something that expands the parent,
+        // and a best_fitting element after it.
+        //
+        // interned 1 [
+        //   expand_parent,
+        //   best_fitting(...)
+        // ]
+        let interned = Interned::new(vec![FormatElement::ExpandParent, unsafe {
+            FormatElement::BestFitting(BestFittingElement::from_vec_unchecked(vec![
+                Box::new([FormatElement::StaticText { text: "a" }]),
+                Box::new([FormatElement::StaticText { text: "b" }]),
+            ]))
+        }]);
+
+        let mut document = Document::from(vec![
+            // First group, processes the interned element for the first time.
+            FormatElement::Tag(StartGroup(tag::Group::new())),
+            FormatElement::Interned(interned.clone()),
+            FormatElement::Tag(EndGroup),
+            // Second group, references the already-processed interned element.
+            FormatElement::Tag(StartGroup(tag::Group::new())),
+            FormatElement::Interned(interned),
+            FormatElement::Tag(EndGroup),
+        ]);
+
+        // After propagation, both groups _should_ be expanded.
+        document.propagate_expand();
+
+        assert_eq!(
+            &std::format!("{document}"),
+            r#"[
+  group(expand: propagated, [
+    <interned 0> [
+      expand_parent,
+      best_fitting([
+        ["a"]
+        ["b"]
+      ])
+    ]
+  ]),
+  group(expand: propagated, [<ref interned *0>])
 ]"#
         );
     }