//! 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) {
self.marker(|tags, out| tags.opening_tag_prefix(id, out));
let group = self.docs.group();
self.print_opening_tag(id);
self.docs.close(group);
let content = tags.node_content(id);
self.lines(content, Separator::Literal);
self.print_closing_tag(id);
self.marker(|tags, out| tags.closing_tag_suffix(id, out));
return;
}
let first = self.tree.first_child(id);
let last = self.tree.last_child(id);
let hug = match (first, last) {
(Some(first), Some(last)) if first == last => {
let child = &self.tree[first];
child.kind == Kind::Interpolation
&& child.flags & (Flags::IS_LEADING_SPACE_SENSITIVE | Flags::HAS_LEADING_SPACES)
== Flags::IS_LEADING_SPACE_SENSITIVE
&& child.flags & (Flags::IS_TRAILING_SPACE_SENSITIVE | Flags::HAS_TRAILING_SPACES)
== Flags::IS_TRAILING_SPACE_SENSITIVE
}
_ => false,
};
let attr_group = self.docs.group_id();
// `printTag`: `group([group(printOpeningTag(..), { id }), contents, printClosingTag(..)])`
let tag = self.docs.group();
let opening = self.docs.group_with(Some(attr_group), false);
self.print_opening_tag(id);
self.docs.close(opening);
match (first, last) {
(Some(first), Some(last)) => {
if self.tree.force_break_content(id, self.options) {
self.docs.break_parent();
}
let indented = !hug && !self.is_unindented_vue_block(id);
let container = if hug {
Some(self.docs.indent_if_break(attr_group, false))
} else if indented {
Some(self.docs.indent())
} else {
None
};
let first_node = &self.tree[first];
if hug {
let broken = self.docs.if_break(Branch::Break, Some(attr_group));
self.docs.softline();
self.docs.close(broken);
} else if first_node
.flags
.contains(Flags::HAS_LEADING_SPACES | Flags::IS_LEADING_SPACE_SENSITIVE)
{
self.docs.line();
} else if first_node.kind == Kind::Text
&& node.flags.contains(Flags::IS_WHITESPACE_SENSITIVE | Flags::IS_INDENTATION_SENSITIVE)
{
let root = self.docs.align(Align::Root);
self.docs.softline();
self.docs.close(root);
} else {
self.docs.softline();
}
if indented {
self.indents += 1;
}
self.print_children(id);
if indented {
self.indents -= 1;
}
if let Some(container) = container {
self.docs.close(container);
}
self.line_after_children(id, last, hug, attr_group);
}
_ => {
if node.flags.contains(Flags::HAS_DANGLING_SPACES | Flags::IS_DANGLING_SPACE_SENSITIVE) {
self.docs.line();
}
}
}
self.print_closing_tag(id);
self.docs.close(tag);
}
/// A Vue root `