//! Prettier's `printer-html.js`, `print/children.js`, `print/element.js` and `print/tag.js`, emitting the doc stream. use std::borrow::Cow; use super::ast::{self, Flags, Id, Kind, Tree}; use super::embed::{self, Embedded}; use super::tag::Tags; use super::utilities::{ dedent_string, html_split, html_trim_preserve_indentation, is_pre_like, is_script_like_tag, is_text_like, should_unquote_attribute_value, unescape_quote_entities, }; use super::{Options, Parser}; use crate::doc::{Align, Branch, Docs}; use crate::embed::Embed; use crate::strings; pub(crate) struct Printer<'p, 'a> { /// The text that is formatted, which texts that are part of it borrow from. source: &'a str, /// A buffer for the markers of tags. buffer: Vec, /// Whether texts escape `"` as `"`, as in the value of an attribute. pub(crate) quotes: bool, pub(crate) tree: &'p Tree<'a>, pub(crate) options: &'p Options<'p>, pub(crate) docs: &'p mut Docs<'a>, pub(crate) embed: &'p mut dyn Embed, /// The number of `indent`s around what is printed now. pub(crate) indents: usize, /// `path.ancestors.length` of the node printed now. ancestors: usize, } /// What `printBetweenLine` returns. #[derive(Clone, Copy, PartialEq, Eq)] enum Between { None, Hard, Line, Soft, } impl<'p, 'a> Printer<'p, 'a> { pub(crate) fn new( source: &'a str, tree: &'p Tree<'a>, options: &'p Options<'p>, docs: &'p mut Docs<'a>, embed: &'p mut dyn Embed, ) -> Self { Self { source, buffer: Vec::new(), quotes: false, tree, options, docs, embed, indents: 0, ancestors: 0, } } pub(crate) fn tags(&self) -> Tags<'p, 'a, 'p> { Tags { tree: self.tree, options: self.options } } /// Emits a text, borrowed from the source when it is part of it. pub(crate) fn bytes(&mut self, bytes: &[u8]) { if self.quotes && strings::contains_char(bytes, b'"') { let escaped = replace(bytes, b"\"", b"""); self.quotes = false; self.bytes(&escaped); self.quotes = true; return; } let start = (bytes.as_ptr() as usize).wrapping_sub(self.source.as_ptr() as usize); if let Some(text) = self.source.get(start..start + bytes.len()) { return self.docs.text(text); } match std::str::from_utf8(bytes) { Ok(text) => self.docs.owned(text), Err(_) => self.docs.owned(&String::from_utf8_lossy(bytes)), } } /// Emits the string that `write` builds from the tag markers. pub(crate) fn marker(&mut self, write: impl FnOnce(Tags<'p, 'a, 'p>, &mut Vec)) { let mut out = std::mem::take(&mut self.buffer); out.clear(); write(self.tags(), &mut out); match std::str::from_utf8(&out) { Ok(text) => self.docs.owned(text), Err(_) => self.docs.owned(&String::from_utf8_lossy(&out)), } self.buffer = out; } /// `replaceEndOfLine(text, separator)` pub(crate) fn lines(&mut self, text: &[u8], separator: Separator) { for (index, line) in strings::split(text, b"\n").enumerate() { if index > 0 { self.separator(separator); } self.bytes(line); } } fn separator(&mut self, separator: Separator) { match separator { Separator::Literal => self.docs.literalline(), Separator::Hard => self.docs.hardline(), } } // ───────────────────────────── `genericPrint` ───────────────────────────── pub(crate) fn print_root(&mut self) { let root = self.tree.root; self.ancestors = 0; let group = self.docs.group(); self.print_children(root); self.docs.close(group); self.docs.hardline(); } /// `path.call(print)` for `id`: the embedded printer first, then `genericPrint`. fn print(&mut self, id: Id) { if self.print_embedded(id) { return; } let node = &self.tree[id]; match node.kind { Kind::Element | Kind::IeConditionalComment => self.print_element(id), Kind::IeConditionalStartComment | Kind::IeConditionalEndComment => { self.marker(|tags, out| tags.opening_tag_start(id, out)); self.marker(|tags, out| tags.closing_tag_end(id, out)); } Kind::Interpolation => { self.marker(|tags, out| tags.opening_tag_start(id, out)); let mut next = self.tree.first_child(id); while let Some(child) = next { next = self.tree.next(child); self.print_nested(child); } self.marker(|tags, out| tags.closing_tag_end(id, out)); } Kind::Text => self.print_text(id), Kind::DocType => { let group = self.docs.group(); self.marker(|tags, out| tags.opening_tag_start(id, out)); self.docs.text(" "); let value = doc_type_value(&node.value); self.bytes(&value); self.docs.close(group); self.marker(|tags, out| tags.closing_tag_end(id, out)); } Kind::Comment => { self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let span = node.span; let text = &self.options.original_text[span.start as usize..span.end as usize]; self.lines(text, Separator::Literal); self.marker(|tags, out| tags.closing_tag_suffix(id, out)); } Kind::FrontMatter => { let span = node.span; let raw = &self.options.original_text[span.start as usize..span.end as usize]; if !embed::front_matter(self, raw) { self.lines(raw, Separator::Literal); } } _ => {} } } /// Prints a child, one level deeper. fn print_nested(&mut self, id: Id) { self.ancestors += 1; self.print(id); self.ancestors -= 1; } fn print_text(&mut self, id: Id) { let node = &self.tree[id]; let parent = self.tree.parent(id).map(|parent| &self.tree[parent]); if parent.is_some_and(|parent| parent.kind == Kind::Interpolation) { let value = &node.value[..]; let trailing = trailing_newline(value); self.lines(trailing.map_or(value, |at| &value[..at]), Separator::Literal); if trailing.is_some() { self.docs.hardline(); } return; } // `fill(getTextValueParts(node))`, with the prefix in the first part and the suffix in the last. let fill = self.docs.fill(); let mut part = self.docs.part(); self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let value = &node.value[..]; let parent = &self.tree[self.tree.parent(id).unwrap_or(self.tree.root)]; let mut write = |printer: &mut Self, index: usize, piece: &[u8], separator: Option| { if index > 0 { printer.docs.close(part); let between = printer.docs.part(); match separator { Some(separator) => printer.separator(separator), None => printer.docs.line(), } printer.docs.close(between); part = printer.docs.part(); } printer.bytes(piece); }; if parent.has(Flags::IS_WHITESPACE_SENSITIVE) { if parent.has(Flags::IS_INDENTATION_SENSITIVE) { for (index, line) in strings::split(value, b"\n").enumerate() { write(self, index, line, Some(Separator::Literal)); } } else { let dedented = dedent_string(html_trim_preserve_indentation(value)); for (index, line) in strings::split(&dedented, b"\n").enumerate() { write(self, index, line, Some(Separator::Hard)); } } } else { for (index, word) in html_split(value).enumerate() { write(self, index, word, None); } } self.marker(|tags, out| tags.closing_tag_suffix(id, out)); self.docs.close(part); self.docs.close(fill); } // ───────────────────────────── `print/children.js` ───────────────────────────── /// `getEndLocation` fn end_location(&self, id: Id) -> u32 { let node = &self.tree[id]; let end = node.span.end; if node.kind == Kind::Element && node.end_span().is_none() && let Some(last) = self.tree.last_child(id) { return end.max(self.end_location(last)); } end } fn print_child(&mut self, id: Id) { if !self.tree.has_prettier_ignore(id) { return self.print_nested(id); } let tags = self.tags(); let node = &self.tree[id]; let mut start = node.span.start as usize; if self .tree .prev(id) .is_some_and(|prev| tags.needs_to_borrow_next_opening_tag_start_marker(prev)) { start += tags.len_of(|tags, out| tags.opening_tag_start_marker(id, out)); } let mut end = self.end_location(id) as usize; if self.tree.next(id).is_some_and(|next| tags.needs_to_borrow_prev_closing_tag_end_marker(next)) { end -= tags.len_of(|tags, out| tags.closing_tag_end_marker(id, out)); } let text = self.options.original_text.get(start..end).unwrap_or_default(); let text = strings::trim_html_whitespace_end(text); self.marker(|tags, out| tags.opening_tag_prefix(id, out)); self.lines(text, Separator::Literal); self.marker(|tags, out| tags.closing_tag_suffix(id, out)); } fn between(&self, prev: Id, next: Id) -> Between { let tags = self.tags(); let (before, after) = (&self.tree[prev], &self.tree[next]); let hard_leading = self.tree.prefer_hardline_as_leading_spaces(next, self.options); if is_text_like(before) && is_text_like(after) { if before.has(Flags::IS_TRAILING_SPACE_SENSITIVE) { if before.has(Flags::HAS_TRAILING_SPACES) { return if hard_leading { Between::Hard } else { Between::Line }; } return Between::None; } return if hard_leading { Between::Hard } else { Between::Soft }; } if (tags.needs_to_borrow_next_opening_tag_start_marker(prev) && (self.tree.has_prettier_ignore(next) || self.tree.first_child(next).is_some() || after.has(Flags::IS_SELF_CLOSING) || (after.kind == Kind::Element && after.has_attrs()))) || (before.kind == Kind::Element && before.has(Flags::IS_SELF_CLOSING) && tags.needs_to_borrow_prev_closing_tag_end_marker(next)) { return Between::None; } if after.kind == Kind::Comment && after.has(Flags::IS_LEADING_SPACE_SENSITIVE) && !after.has(Flags::HAS_LEADING_SPACES) { return Between::Soft; } let borrows_deep = || { tags.needs_to_borrow_prev_closing_tag_end_marker(next) && self.tree.last_child(prev).is_some_and(|last| { tags.needs_to_borrow_parent_closing_tag_start_marker(last) && self .tree .last_child(last) .is_some_and(|deep| tags.needs_to_borrow_parent_closing_tag_start_marker(deep)) }) }; if !after.has(Flags::IS_LEADING_SPACE_SENSITIVE) || hard_leading || borrows_deep() { return Between::Hard; } if after.has(Flags::HAS_LEADING_SPACES) { Between::Line } else { Between::Soft } } fn emit_between(&mut self, between: Between) { match between { Between::None => {} Between::Hard => self.docs.hardline(), Between::Line => self.docs.line(), Between::Soft => self.docs.softline(), } } fn print_children(&mut self, id: Id) { if self.tree.force_break_children(id) { self.docs.break_parent(); let mut next = self.tree.first_child(id); while let Some(child) = next { next = self.tree.next(child); if let Some(prev) = self.tree.prev(child) { let between = self.between(prev, child); if between != Between::None { self.emit_between(between); if self.tree.force_next_empty_line(prev, self.options) { self.docs.hardline(); } } } self.print_child(child); } return; } // The group of the previous child, which `ifBreak` looks at. let mut previous = None; let mut next = self.tree.first_child(id); while let Some(child) = next { next = self.tree.next(child); let prev = self.tree.prev(child); let group = self.docs.group_id(); let current = previous.replace(group); if is_text_like(&self.tree[child]) { if let Some(prev) = prev.filter(|&prev| is_text_like(&self.tree[prev])) { let between = self.between(prev, child); if between != Between::None { if self.tree.force_next_empty_line(prev, self.options) { self.docs.hardline(); self.docs.hardline(); } else { self.emit_between(between); } } } self.print_child(child); continue; } let mut before = 0; let mut leading = Leading::None; let mut trailing = Between::None; let mut after = 0; if let Some(prev) = prev { let between = self.between(prev, child); if between != Between::None { if self.tree.force_next_empty_line(prev, self.options) { before = 2; } else if between == Between::Hard { before = 1; } else if is_text_like(&self.tree[prev]) { leading = Leading::Line(between); } else { leading = Leading::Soft; } } } if let Some(next) = next { let between = self.between(child, next); if between != Between::None { let next_is_text = is_text_like(&self.tree[next]); if self.tree.force_next_empty_line(child, self.options) { after = if next_is_text { 2 } else { 0 }; } else if between == Between::Hard { after = usize::from(next_is_text); } else { trailing = between; } } } for _ in 0..before { self.docs.hardline(); } let outer = self.docs.group(); match leading { Leading::None => {} Leading::Line(between) => self.emit_between(between), Leading::Soft => { let flat = self.docs.if_break(Branch::Flat, current); self.docs.softline(); self.docs.close(flat); } } let inner = self.docs.group_with(Some(group), false); self.print_child(child); self.emit_between(trailing); self.docs.close(inner); self.docs.close(outer); for _ in 0..after { self.docs.hardline(); } } } // ───────────────────────────── `print/element.js` ───────────────────────────── fn print_element(&mut self, id: Id) { let tags = self.tags(); let node = &self.tree[id]; if node.has(Flags::PRESERVES_CONTENT) { // The tags already print the markers that they borrow, and Prettier prints those again around them: // `a>
`. A whitespace-only `
` or `