fix(formatter_markdown): fixed remaining issues found by fuzz (#27334)

- keep a lazy HTML block's continuation lines in the list item
- print a footnote paragraph on its marker line only when it prints as one line

Author: leaysgur

crates/oxc_formatter_markdown/AGENTS.md

@@ -96,4 +96,8 @@ Extend the ignore set only with a reason written next to it.
 `tests/invariants.rs` formats a deterministic token-soup corpus (the parser repo's differential generator) under every `proseWrap` and checks the fingerprint and idempotency.
 The default corpus must fail exactly on `KNOWN_FAILURES` (the documents and their classes are listed there);
 remove an entry when its class is fixed, any other failure is a regression.
+
+Other seeds pass (3 / 5 / 7 / 8 / 13 / 21 / 42 / 99) except one known class, seed 11 #5:
+a liquid tag continued on a lazy line (`2. {% x` + `y %}`) is inline in a paragraph,
+re-indented into the item it becomes a liquid flow block (micromark reads the two the same way).
 `MD_FUZZ_SEED` / `MD_FUZZ_COUNT` run other corpora, `MD_FUZZ_FILE` prints one document's fingerprints.

crates/oxc_formatter_markdown/DIVERGENCES.md

@@ -214,6 +214,20 @@ though no type 7 block can interrupt a paragraph on a regular line.
 Printed with the container's prefix the line is no longer lazy, so a blank line keeps the block apart;
 Prettier prints it adjacent, and the next parse reads it as part of the paragraph.
 
+In a tight list item the line stays lazy, and the block's other lines keep the item's content column:
+
+```markdown
+<!-- input, ours -->
+- a
+<a>
+    b
+
+<!-- prettier (the html loses the 2 columns before `b`) -->
+- a
+<a>
+  b
+```
+
 ## list-after-html-block
 
 - Why: semantics (prettier/prettier#17690)
@@ -636,3 +650,34 @@ a
 A fenced code block whose info string has a backtick keeps its `~~~` fence; any other fence is printed with backticks.
 A backtick fence cannot have a backtick in its info string (CommonMark),
 so Prettier's opener is a paragraph on the next parse and its closer opens a code block that runs to the end of the document.
+
+## footnote-kept-line-break
+
+- Why: semantics
+- Pin: `tests/fixtures/markdown/prose-wrap/footnote-kept-line-break.md`
+
+```markdown
+<!-- input -->
+[^1]: a b\
+=
+
+<!-- ours (every proseWrap) -->
+[^1]:
+    a b\
+        =
+
+<!-- prettier, preserve (a setext heading on the next parse) -->
+[^1]:
+    a b\
+    =
+
+<!-- prettier, never -->
+[^1]: a b\
+=
+```
+
+A footnote's single paragraph follows the marker only when it prints as one line, under every `proseWrap`:
+`always` also breaks it for the width, the other modes only for a line break the paragraph keeps.
+Prettier asks `preserve` whether the source is one line, and its block form above moves the lazy `=` into the footnote,
+where it underlines the paragraph.
+Its `never` keeps the marker line whatever the paragraph holds (admissible here); ours follows the same rule as the other modes.

crates/oxc_formatter_markdown/src/print/block.rs

@@ -1,7 +1,7 @@
 //! Block dispatch and the blank-line policy between siblings.
 
 use oxc_formatter_core::{
-    Buffer,
+    Buffer, FormatElements, MemoizeFormat,
     builders::{
         exact_line_breaks, group, hard_line_break, literal_line_break, mark_as_root,
         soft_line_break_or_space, space, space_align, text, token,
@@ -72,7 +72,7 @@ pub fn write_blocks<'a>(
     }
 }
 
-pub fn write_gap(
+fn write_gap(
     siblings: &[Block<'_>],
     index: usize,
     parent: Parent,
@@ -82,7 +82,7 @@ pub fn write_gap(
 }
 
 /// Whether `siblings[index]` gets a blank line before it.
-fn double_gap(
+pub fn double_gap(
     siblings: &[Block<'_>],
     index: usize,
     parent: Parent,
@@ -322,47 +322,33 @@ fn write_heading<'a>(
     }
 }
 
-/// `[^label]: ` + content.
-/// A lone paragraph stays on the label's line under `never` (and under `preserve` when it is one source line);
-/// otherwise the content is aligned by 4 and the first block moves to its own line when it does not fit
-/// (or is multi-line).
+/// `[^label]: ` + content, aligned by 4.
+/// A lone paragraph that prints as one line stays on the label's line (under `always` the group decides),
+/// anything else starts on the next line (DIVERGENCES.md#footnote-kept-line-break).
 fn write_footnote_definition<'a>(
     def: &'a FootnoteDefinition<'a>,
     f: &mut MarkdownFormatter<'_, 'a>,
 ) {
     write!(f, [token("[^"), text(f.context().slice(def.label)), token("]:")]);
     let children = &def.children;
-    let inline = match children.as_slice() {
-        [Block::Paragraph(p)] => match f.options().prose_wrap {
-            ProseWrap::Never => true,
-            // Prettier asks whether the source paragraph is one line;
-            // asking whether it prints as one keeps the answer stable across passes
-            // (a line break joined away would flip it).
-            ProseWrap::Preserve => !inline::keeps_a_line_break(&p.children, f),
-            ProseWrap::Always => false,
-        },
-        _ => false,
-    };
-    if inline {
-        write!(f, space());
-        write_blocks(children, Parent::Container, f);
-        return;
-    }
     let parent = Parent::Container;
-    write!(
-        f,
-        space_align(
-            4,
-            &mark_as_root(&format_with(|f| {
-                let first = format_with(|f| write_block(&children[0], children, 0, parent, f));
-                write!(f, group(&format_args!(soft_line_break_or_space(), first)));
-                for index in 1..children.len() {
-                    write_gap(children, index, parent, f);
-                    write_block(&children[index], children, index, parent, f);
-                }
-            }))
-        )
-    );
+    let first = format_with(|f| write_block(&children[0], children, 0, parent, f)).memoized();
+    let on_label_line = matches!(children.as_slice(), [Block::Paragraph(_)])
+        && f.options().prose_wrap != ProseWrap::Always
+        && !first.inspect(f).will_break();
+    let body = format_with(|f| {
+        if on_label_line {
+            write!(f, [space(), first]);
+        } else {
+            write!(f, group(&format_args!(soft_line_break_or_space(), first)));
+        }
+        for index in 1..children.len() {
+            write_gap(children, index, parent, f);
+            write_block(&children[index], children, index, parent, f);
+        }
+    });
+    // Also on the label's line: the 4-space guard of a block-start-looking line counts from the content column
+    write!(f, space_align(4, &mark_as_root(&body)));
 }
 
 /// `---`, except inside a list

crates/oxc_formatter_markdown/src/print/inline.rs

@@ -203,23 +203,6 @@ fn markers_as_written(f: &MarkdownFormatter<'_, '_>) -> bool {
     f.context().raw_text().get() == Raw::Line || f.context().literal_markers().get()
 }
 
-/// Under `proseWrap: preserve`, whether any soft break of this paragraph survives printing
-/// (one before a block-start-looking word is joined away; one next to a dialect shape line stays).
-pub fn keeps_a_line_break<'a>(children: &'a [Inline<'a>], f: &MarkdownFormatter<'_, 'a>) -> bool {
-    let last = children.len().wrapping_sub(1);
-    children.iter().enumerate().any(|(i, child)| {
-        matches!(child, Inline::SoftBreak(_))
-            && i != 0
-            && i != last
-            && (line_shape(children, i + 1, false, false, f)
-                || !words::prevents_break(
-                    true,
-                    next_word_of(children, i, None, f),
-                    ProseWrap::Preserve,
-                ))
-    })
-}
-
 /// Prettier's `riskyParagraphPositions`: a `[[` in text, followed by `]]` (text or a wiki link's).
 /// Wrapping such a paragraph could merge `[[foo\n[[wiki link]]` into one link,
 /// so its text is printed as written.

crates/oxc_formatter_markdown/src/print/list.rs

@@ -5,7 +5,7 @@
 
 use oxc_formatter_core::{
     Buffer,
-    builders::{mark_as_root, space_align, text, token},
+    builders::{dedent, hard_line_break, mark_as_root, space_align, text, token},
     write,
 };
 use oxc_markdown_parser::{
@@ -87,24 +87,10 @@ pub fn write_list<'a>(
         let prefix: &'a str = f.allocator().alloc_str(&prefix);
         write!(f, text(prefix));
 
-        // A `[paragraph, html]` item whose html sits left of the content column is
-        // micromark's lazy type 7 quirk (oxc-markdown-parser DIVERGENCES.md): the html stays where it was, unaligned.
-        // (Prettier drops the alignment whenever the two columns differ,
-        // which moves an html block indented past a task checkbox out of the item:
-        // DIVERGENCES.md#list-html-block-alignment)
-        let skip_align =
-            item.children.len() == 2 && matches!(item.children[1], Block::HtmlBlock(_)) && {
-                let source = f.context().source_text().as_str();
-                let content_column = item
-                    .checkbox
-                    .map_or(item.children[0].span().start, |checkbox| checkbox.span.start);
-                column_of(source, item.children[1].span().start) < column_of(source, content_column)
-            };
         let body = format_with(|f| write_list_item(item, checkbox, prefix.len(), loose, f));
-        let width = if skip_align { 0 } else { prefix.len() };
         // The item's content column is the root that verbatim continuation lines return to.
         // Its columns are syntax, spaces under `useTabs` too (see `space_align`).
-        write!(f, space_align(width, &mark_as_root(&body)));
+        write!(f, space_align(prefix.len(), &mark_as_root(&body)));
     }
 
     f.context().lists().borrow_mut().pop();
@@ -127,7 +113,19 @@ fn write_list_item<'a>(
 
     for (i, child) in item.children.iter().enumerate() {
         if i > 0 {
-            block::write_gap(&item.children, i, parent, f);
+            let blank = block::double_gap(&item.children, i, parent, f);
+            // A type 7 HTML block right after a paragraph starts on a lazy line
+            // (micromark's quirk, oxc-markdown-parser DIVERGENCES.md): that line stays in the parent's column,
+            // the block's other lines are in the item (DIVERGENCES.md#lazy-html-block)
+            let lazy_html = matches!(
+                (&item.children[i - 1], child),
+                (Block::Paragraph(_), Block::HtmlBlock(h)) if h.kind == 7
+            );
+            if lazy_html && !blank {
+                write!(f, dedent(&hard_line_break()));
+            } else {
+                write_gap(blank, f);
+            }
         }
         // The first block follows the checkbox on its line: its first line is not a line start
         let child_parent = if i == 0 && !checkbox.is_empty() {

crates/oxc_formatter_markdown/src/print/text.rs

@@ -241,7 +241,7 @@ pub fn push_whitespace<'a>(
 }
 
 /// Never break before a word that would start a block.
-pub fn prevents_break(newline: bool, next: Option<NextWord<'_>>, prose_wrap: ProseWrap) -> bool {
+fn prevents_break(newline: bool, next: Option<NextWord<'_>>, prose_wrap: ProseWrap) -> bool {
     let Some(next) = next else { return false };
     if next.escaped {
         return false;

crates/oxc_formatter_markdown/tests/fixtures/markdown/lazy-html-block.md

@@ -1,3 +1,23 @@
 > a
 <a>
 > c
+
+- a
+<a>
+    b
+
+* a\
+      # x
+<a>
+    b
+
+1. a
+<a>
+   b
+
+2. c
+
+- # h
+  a
+<a>
+    b

crates/oxc_formatter_markdown/tests/fixtures/markdown/lazy-html-block.md.snap

@@ -6,6 +6,26 @@ source: crates/oxc_formatter_markdown/tests/fixtures/mod.rs
 <a>
 > c
 
+- a
+<a>
+    b
+
+* a\
+      # x
+<a>
+    b
+
+1. a
+<a>
+   b
+
+2. c
+
+- # h
+  a
+<a>
+    b
+
 ==================== Output ====================
 ------------------
 { printWidth: 80 }
@@ -15,6 +35,27 @@ source: crates/oxc_formatter_markdown/tests/fixtures/mod.rs
 > <a>
 > c
 
+- a
+<a>
+    b
+
+* a\
+      # x
+<a>
+    b
+
+1. a
+
+   <a>
+   b
+
+2. c
+
+- # h
+  a
+<a>
+    b
+
 -------------------
 { printWidth: 100 }
 -------------------
@@ -23,4 +64,25 @@ source: crates/oxc_formatter_markdown/tests/fixtures/mod.rs
 > <a>
 > c
 
+- a
+<a>
+    b
+
+* a\
+      # x
+<a>
+    b
+
+1. a
+
+   <a>
+   b
+
+2. c
+
+- # h
+  a
+<a>
+    b
+
 ===================== End =====================

crates/oxc_formatter_markdown/tests/fixtures/markdown/prose-wrap/footnote-kept-line-break.md

@@ -0,0 +1,8 @@
+[^1]: a b\
+=
+
+[^2]: *a\
+b*
+
+[^3]: a
+b