use std::cell::RefCell;
use std::collections::HashMap;
use std::iter::Peekable;
use rowan::{TextRange, TextSize};
use super::colspec::{self, ColAlign};
use crate::ast::{AstNode, Command, Environment, Group, command_name};
use crate::declarations::ResolvedDeclarations;
use crate::directives;
use crate::parser::is_def_prefix_command;
use crate::parser::lexer::{ExplToggle, expl_toggle};
use crate::parser::{LatexFlavor, parse_with_declarations, parse_with_flavor};
use crate::semantic::expl3::{StatementMap, segment_expl_statements};
use crate::semantic::signature::document_class_signatures;
use crate::semantic::tikz::statement_glue;
use crate::semantic::{
ArgKind, ArgSpec, ArgumentDomain, CitationPlacement, ContentKind, DelimiterRole, MathClass,
SignatureDb, Signatures, expl3, match_arg_slot, match_verbatim_arg_slot, math_atoms,
scan_definitions,
};
use crate::syntax::{
SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, is_collapsible_trivia, is_param_digit,
is_trivia,
};
use super::context::FormatContext;
use super::ir::Ir;
use super::printer::Printer;
use super::sentence::{ResolvedProfile, SentenceOptions, is_sentence_boundary_text};
use super::style::{
FormatStyle, ItemIndent, LineEnding, MathWrap, WrapMode, apply_line_ending, detect_line_ending,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FormatError {
ParseErrors { count: usize },
UnsupportedConstruct { kind: SyntaxKind, snippet: String },
}
impl std::fmt::Display for FormatError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::ParseErrors { count } => write!(
f,
"input contains {count} parser diagnostic(s); formatter only supports parseable input"
),
Self::UnsupportedConstruct { kind, snippet } => {
write!(
f,
"unsupported construct for formatter: {kind:?} near {snippet:?}"
)
}
}
}
}
impl std::error::Error for FormatError {}
pub fn format(input: &str) -> Result<String, FormatError> {
format_with_style(input, FormatStyle::default())
}
pub fn format_with_style(input: &str, style: FormatStyle) -> Result<String, FormatError> {
format_with_style_flavored(input, style, LatexFlavor::Document)
}
pub fn format_with_style_flavored(
input: &str,
style: FormatStyle,
config: impl Into<crate::parser::LexConfig>,
) -> Result<String, FormatError> {
format_with_style_flavored_with_signatures(input, style, config, &SignatureDb::default())
}
pub fn format_with_style_flavored_sentence(
input: &str,
style: FormatStyle,
config: impl Into<crate::parser::LexConfig>,
sentence: SentenceOptions<'_>,
) -> Result<String, FormatError> {
let parsed = parse_with_flavor(input, config);
if !parsed.errors.is_empty() {
return Err(FormatError::ParseErrors {
count: parsed.errors.len(),
});
}
format_node_with_signatures_sentence(&parsed.syntax(), style, &SignatureDb::default(), sentence)
}
pub fn format_with_declarations_sentence(
input: &str,
style: FormatStyle,
config: impl Into<crate::parser::LexConfig>,
sentence: SentenceOptions<'_>,
declared: &ResolvedDeclarations,
) -> Result<String, FormatError> {
let parsed = parse_with_declarations(input, config, declared);
if !parsed.errors.is_empty() {
return Err(FormatError::ParseErrors {
count: parsed.errors.len(),
});
}
format_node_with_signatures_sentence(
&parsed.syntax(),
style,
&declared_scope(declared),
sentence,
)
}
pub fn declared_scope(declared: &ResolvedDeclarations) -> SignatureDb {
let mut scope = SignatureDb::default();
scope.merge_declarations(declared);
scope
}
pub fn format_with_style_flavored_with_signatures(
input: &str,
style: FormatStyle,
config: impl Into<crate::parser::LexConfig>,
external: &SignatureDb,
) -> Result<String, FormatError> {
let parsed = parse_with_flavor(input, config);
if !parsed.errors.is_empty() {
return Err(FormatError::ParseErrors {
count: parsed.errors.len(),
});
}
format_node_with_signatures(&parsed.syntax(), style, external)
}
pub fn format_node(root: &SyntaxNode, style: FormatStyle) -> Result<String, FormatError> {
format_node_with_signatures(root, style, &SignatureDb::default())
}
pub fn format_node_with_signatures(
root: &SyntaxNode,
style: FormatStyle,
external: &SignatureDb,
) -> Result<String, FormatError> {
format_node_with_signatures_sentence(root, style, external, SentenceOptions::default())
}
pub fn format_node_with_signatures_sentence(
root: &SyntaxNode,
style: FormatStyle,
external: &SignatureDb,
sentence: SentenceOptions<'_>,
) -> Result<String, FormatError> {
validate_supported_tokens(root)?;
let ctx = FormatContext::with_sentence(style, sentence);
let mut formatted = format_root(root, ctx, external, None);
let trimmed_len = formatted.trim_end_matches([' ', '\t', '\n', '\r']).len();
formatted.truncate(trimmed_len);
if !formatted.is_empty() {
formatted.push('\n');
}
apply_line_ending(&mut formatted, resolve_line_ending(root, style));
Ok(formatted)
}
pub fn format_node_range_with_signatures(
root: &SyntaxNode,
style: FormatStyle,
external: &SignatureDb,
range: TextRange,
) -> Result<String, FormatError> {
format_node_range_with_signatures_sentence(
root,
style,
external,
range,
SentenceOptions::default(),
)
}
pub fn format_node_range_with_signatures_sentence(
root: &SyntaxNode,
style: FormatStyle,
external: &SignatureDb,
range: TextRange,
sentence: SentenceOptions<'_>,
) -> Result<String, FormatError> {
validate_supported_tokens(root)?;
let ctx = FormatContext::with_sentence(style, sentence);
let mut formatted = format_root(root, ctx, external, Some(range));
let trimmed_len = formatted.trim_end_matches([' ', '\t', '\n', '\r']).len();
formatted.truncate(trimmed_len);
apply_line_ending(&mut formatted, resolve_line_ending(root, style));
Ok(formatted)
}
fn resolve_line_ending(root: &SyntaxNode, style: FormatStyle) -> LineEnding {
if style.line_ending == LineEnding::Auto {
style.line_ending.resolve(detect_line_ending(&root.text()))
} else {
style.line_ending.resolve(LineEnding::Lf)
}
}
fn validate_supported_tokens(root: &SyntaxNode) -> Result<(), FormatError> {
for element in root.descendants_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
if token.kind() == SyntaxKind::ERROR {
return Err(FormatError::UnsupportedConstruct {
kind: token.kind(),
snippet: token.text().to_string(),
});
}
}
Ok(())
}
fn format_root(
root: &SyntaxNode,
ctx: FormatContext,
external: &SignatureDb,
range: Option<TextRange>,
) -> String {
let mut user = document_class_signatures(root).cloned().unwrap_or_default();
user.merge_from(external, None);
user.merge_from(&scan_definitions(root), None);
let regions = expl3_regions(root);
let suppressed = directives::Suppressions::build(root);
let profile = ctx.sentence().resolved();
let dtx_reflow_cache = DtxReflowCache::default();
let algorithm2e_cache = RefCell::new(HashMap::new());
let cx = LowerCtx {
wrap: ctx.style().wrap,
item_indent: ctx.style().item_indent,
indent_width: ctx.style().indent_width,
math_wrap: ctx.style().math_wrap.resolve(ctx.style().wrap),
stable_target: ctx.style().stable_wrap_target(),
signatures: Signatures::new(&user),
expl3_regions: ®ions,
suppressed: suppressed.format_ranges(),
profile,
range,
dtx_reflow_cache: &dtx_reflow_cache,
algorithm2e_cache: &algorithm2e_cache,
dtx_margin_probe: false,
preserve_dtx_nested_layout: false,
in_dtx_doc_region: false,
in_alignment_cell: false,
absorbed_control_newline: None,
omitted_leading_comment: None,
is_dtx: root
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| matches!(t.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD)),
};
let ir = lower_node(root, cx).propagate_breaks();
Printer::new(ctx.style()).print(&ir)
}
fn ranges_overlap(a: TextRange, b: TextRange) -> bool {
a.start() < b.end() && b.start() < a.end()
}
fn document_body_contains(node: &SyntaxNode, range: TextRange) -> bool {
let Some(environment) = Environment::cast(node.clone()) else {
return false;
};
if environment.name().as_deref() != Some("document") {
return false;
}
let (Some(begin), Some(end)) = (environment.begin(), environment.end()) else {
return false;
};
range.start() >= begin.syntax().text_range().end()
&& range.end() <= end.syntax().text_range().start()
}
fn prev_nontrivia_element(node: &SyntaxNode) -> Option<SyntaxElement> {
let mut prev = node.prev_sibling_or_token();
while let Some(el) = prev {
if let SyntaxElement::Token(t) = &el
&& is_collapsible_trivia(t.kind())
{
prev = el.prev_sibling_or_token();
continue;
}
return Some(el);
}
None
}
fn toggle_is_top_level(token: &SyntaxToken) -> bool {
let Some(command) = token.parent() else {
return true;
};
if command.kind() != SyntaxKind::COMMAND {
return true;
}
for ancestor in command.ancestors().skip(1) {
match ancestor.kind() {
SyntaxKind::GROUP | SyntaxKind::OPTIONAL => return false,
SyntaxKind::ROOT => break,
_ => {}
}
}
if let Some(SyntaxElement::Node(prev)) = prev_nontrivia_element(&command)
&& prev.kind() == SyntaxKind::COMMAND
&& let Some(name) = command_name(&prev)
&& (is_def_prefix_command(&format!("\\{name}"))
|| matches!(name.as_str(), "let" | "futurelet"))
{
return false;
}
true
}
pub fn expl3_regions(root: &SyntaxNode) -> Vec<TextRange> {
let mut regions: Vec<TextRange> = Vec::new();
let mut open: Option<TextSize> = None;
for token in root
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.filter(|t| t.kind() == SyntaxKind::CONTROL_WORD)
{
let toggle = match expl_toggle(token.text()) {
Some(t) if toggle_is_top_level(&token) => t,
_ => continue,
};
match toggle {
ExplToggle::On if open.is_none() => open = Some(token.text_range().start()),
ExplToggle::On => {}
ExplToggle::Off => {
if let Some(start) = open.take() {
regions.push(TextRange::new(start, token.text_range().end()));
}
}
}
}
if let Some(start) = open.take() {
regions.push(TextRange::new(start, root.text_range().end()));
}
let regions = intersect_macrocode_bodies(root, regions);
let regions = subtract_doc_margin_lines(root, regions);
subtract_guarded_line_runs(root, regions)
}
fn intersect_macrocode_bodies(root: &SyntaxNode, regions: Vec<TextRange>) -> Vec<TextRange> {
if regions.is_empty()
|| !root
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| t.kind() == SyntaxKind::DOC_MARGIN)
{
return regions;
}
let bodies: Vec<TextRange> = root
.descendants()
.filter(|n| n.kind() == SyntaxKind::ENVIRONMENT)
.filter_map(Environment::cast)
.filter(|e| matches!(e.name().as_deref(), Some("macrocode" | "macrocode*")))
.filter_map(|e| {
let start = e.begin()?.syntax().text_range().end();
let end = e
.end()
.map(|end| end.syntax().text_range().start())
.unwrap_or_else(|| e.syntax().text_range().end());
(start < end).then_some(TextRange::new(start, end))
})
.collect();
let mut out = Vec::with_capacity(regions.len());
let mut b = bodies.iter().peekable();
for region in regions {
while let Some(&&body) = b.peek() {
if body.end() <= region.start() {
b.next();
continue;
}
if body.start() >= region.end() {
break;
}
let start = region.start().max(body.start());
let end = region.end().min(body.end());
if start < end {
out.push(TextRange::new(start, end));
}
if body.end() >= region.end() {
break;
}
b.next();
}
}
out
}
fn subtract_doc_margin_lines(root: &SyntaxNode, regions: Vec<TextRange>) -> Vec<TextRange> {
if regions.is_empty() {
return regions;
}
let mut holes: Vec<TextRange> = Vec::new();
let mut hole_start: Option<TextSize> = None;
for token in root
.descendants_with_tokens()
.filter_map(|e| e.into_token())
{
match token.kind() {
SyntaxKind::DOC_MARGIN => {
hole_start.get_or_insert(token.text_range().start());
}
SyntaxKind::NEWLINE => {
if let Some(start) = hole_start.take() {
holes.push(TextRange::new(start, token.text_range().end()));
}
}
_ => {}
}
}
if let Some(start) = hole_start.take() {
holes.push(TextRange::new(start, root.text_range().end()));
}
subtract_holes(regions, &holes)
}
fn subtract_guarded_line_runs(root: &SyntaxNode, regions: Vec<TextRange>) -> Vec<TextRange> {
if regions.is_empty() {
return regions;
}
let mut holes: Vec<TextRange> = Vec::new();
let mut at_line_start = true;
let mut line_is_guard = false;
let mut cur_line_start = TextSize::new(0);
let mut run: Option<(TextSize, TextSize, usize)> = None;
fn flush(run: &mut Option<(TextSize, TextSize, usize)>, holes: &mut Vec<TextRange>) {
if let Some((start, end, count)) = run.take()
&& count >= 2
{
holes.push(TextRange::new(start, end));
}
}
for token in root
.descendants_with_tokens()
.filter_map(|e| e.into_token())
{
if at_line_start {
cur_line_start = token.text_range().start();
line_is_guard = token.kind() == SyntaxKind::GUARD;
at_line_start = false;
}
if token.kind() == SyntaxKind::NEWLINE {
let line_end = token.text_range().end();
if line_is_guard {
match run {
Some((start, end, count)) if end == cur_line_start => {
run = Some((start, line_end, count + 1));
}
_ => {
flush(&mut run, &mut holes);
run = Some((cur_line_start, line_end, 1));
}
}
} else {
flush(&mut run, &mut holes);
}
at_line_start = true;
}
}
flush(&mut run, &mut holes);
subtract_holes(regions, &holes)
}
fn subtract_holes(regions: Vec<TextRange>, holes: &[TextRange]) -> Vec<TextRange> {
if holes.is_empty() {
return regions;
}
let mut out = Vec::with_capacity(regions.len());
let mut h = holes.iter().peekable();
for region in regions {
let mut cursor = region.start();
while let Some(&&hole) = h.peek() {
if hole.end() <= cursor {
h.next();
continue;
}
if hole.start() >= region.end() {
break;
}
if hole.start() > cursor {
out.push(TextRange::new(cursor, hole.start()));
}
cursor = cursor.max(hole.end());
if cursor >= region.end() {
break;
}
h.next();
}
if cursor < region.end() {
out.push(TextRange::new(cursor, region.end()));
}
}
out
}
#[derive(Clone, Copy)]
struct LowerCtx<'a> {
wrap: WrapMode,
item_indent: ItemIndent,
indent_width: usize,
math_wrap: MathWrap,
stable_target: usize,
signatures: Signatures<'a>,
expl3_regions: &'a [TextRange],
suppressed: &'a [TextRange],
profile: ResolvedProfile<'a>,
range: Option<TextRange>,
dtx_reflow_cache: &'a DtxReflowCache,
algorithm2e_cache: &'a RefCell<HashMap<SyntaxNode, bool>>,
dtx_margin_probe: bool,
preserve_dtx_nested_layout: bool,
in_dtx_doc_region: bool,
in_alignment_cell: bool,
absorbed_control_newline: Option<TextRange>,
omitted_leading_comment: Option<TextRange>,
is_dtx: bool,
}
type DtxReflowCache = RefCell<HashMap<SyntaxNode, bool>>;
impl<'a> LowerCtx<'a> {
fn wraps_prose(self) -> bool {
matches!(
self.wrap,
WrapMode::Reflow | WrapMode::Stable | WrapMode::Sentence | WrapMode::Semantic
)
}
fn absorbing_trailing_control_newline(self, body: &[SyntaxElement]) -> Self {
let Some(token) = trailing_control_newline(body) else {
return self;
};
Self {
absorbed_control_newline: Some(token.text_range()),
..self
}
}
fn absorbs_control_newline(self, token: &SyntaxToken) -> bool {
self.absorbed_control_newline == Some(token.text_range())
}
fn any_expl3(self) -> bool {
!self.expl3_regions.is_empty()
}
fn in_expl3_region(self, at: TextSize) -> bool {
self.expl3_regions
.binary_search_by(|r| {
use std::cmp::Ordering;
if at < r.start() {
Ordering::Greater
} else if at >= r.end() {
Ordering::Less
} else {
Ordering::Equal
}
})
.is_ok()
}
fn overlaps_expl3(self, range: TextRange) -> bool {
self.expl3_regions
.iter()
.any(|r| r.start() < range.end() && range.start() < r.end())
}
fn suppressed(self, range: TextRange) -> bool {
self.suppressed.iter().any(|r| r.contains_range(range))
}
}
fn lower_node(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
if node.kind() != SyntaxKind::ROOT && cx.suppressed(node.text_range()) {
return Ir::verbatim(node.text().to_string());
}
if node.kind() == SyntaxKind::DOC_COMMENT
&& cx.omitted_leading_comment == Some(node.text_range())
{
return Ir::Nil;
}
if cx.is_dtx
&& node.kind() != SyntaxKind::ROOT
&& !inside_macrocode(node)
&& contains_indented_dtx_comment(node)
{
let padding = leading_indented_dtx_comment_padding(node)
.map(Ir::verbatim)
.unwrap_or(Ir::Nil);
return Ir::concat([padding, Ir::verbatim(node.text().to_string())]);
}
if dtx_doc_region(node, cx) {
let virtual_doc = LowerCtx {
in_dtx_doc_region: true,
preserve_dtx_nested_layout: false,
..cx
};
return Ir::doc_margin(lower_node(node, virtual_doc));
}
if cx.is_dtx
&& node.kind() == SyntaxKind::ENVIRONMENT
&& doc_margin_opens_line(node, cx)
&& (environment_begin_has_newline(node) || !is_margin_framed(node))
{
return Ir::verbatim(node.text().to_string());
}
if cx.preserve_dtx_nested_layout
&& matches!(
node.kind(),
SyntaxKind::COMMAND
| SyntaxKind::ENVIRONMENT
| SyntaxKind::GROUP
| SyntaxKind::OPTIONAL
| SyntaxKind::INLINE_MATH
| SyntaxKind::DISPLAY_MATH
| SyntaxKind::MATH
)
{
return Ir::verbatim(node.text().to_string());
}
if node.kind() == SyntaxKind::COMMAND
&& doc_margin_opens_line(node, cx)
&& node
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| t.kind() == SyntaxKind::GUARD)
{
return Ir::verbatim(node.text().to_string());
}
if node.kind() == SyntaxKind::PARAGRAPH
&& doc_margin_opens_line(node, cx)
&& node
.first_token()
.is_some_and(|token| token.kind() == SyntaxKind::CONTROL_WORD)
&& node
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| t.kind() == SyntaxKind::GUARD)
{
return Ir::verbatim(node.text().to_string());
}
if node.kind() == SyntaxKind::PARAGRAPH {
let text = node.text().to_string();
if text_is_fully_guarded(&text) {
return Ir::verbatim(text.trim_start_matches(['\r', '\n']));
}
}
if let Some(range) = cx.range
&& node.kind() == SyntaxKind::ROOT
{
let mut filtered = Vec::new();
for element in node
.children_with_tokens()
.filter(|el| ranges_overlap(range, el.text_range()))
{
if let SyntaxElement::Node(child) = &element
&& document_body_contains(child, range)
{
filtered.extend(
child
.children_with_tokens()
.filter(|el| ranges_overlap(range, el.text_range())),
);
} else {
filtered.push(element);
}
}
return Ir::concat(lower_element_stream(filtered.into_iter(), cx));
}
if cx.any_expl3() {
match node.kind() {
SyntaxKind::PARAGRAPH if cx.overlaps_expl3(node.text_range()) => {
return lower_expl_paragraph(node, cx);
}
SyntaxKind::GROUP if cx.in_expl3_region(node.text_range().start()) => {
return lower_expl_group(node, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx);
}
SyntaxKind::OPTIONAL if cx.in_expl3_region(node.text_range().start()) => {
return lower_expl_group(node, SyntaxKind::L_BRACKET, SyntaxKind::R_BRACKET, cx);
}
SyntaxKind::COMMAND if cx.in_expl3_region(node.text_range().start()) => {
let fill = lower_expl_code(node.children_with_tokens(), cx, Statements::Ignore);
if let Some(exploded) = command_name(node)
.and_then(|name| expl3::conditional_branches(&name))
.and_then(|n| lower_expl_conditional(node, cx, n))
{
return Ir::group(Ir::if_break(fill, exploded));
}
return fill;
}
_ => {}
}
}
match node.kind() {
SyntaxKind::PARAGRAPH
if !cx.in_dtx_doc_region && cx.wraps_prose() && is_dtx_doc_paragraph(node) =>
{
return lower_dtx_doc_paragraph(node, cx);
}
SyntaxKind::PARAGRAPH
if cx.wraps_prose() || in_algorithm2e_env(node, cx) && !is_dtx_doc_paragraph(node) =>
{
return lower_paragraph_reflow(node, cx);
}
SyntaxKind::PARAGRAPH if cx.wrap == WrapMode::Preserve && !is_dtx_doc_paragraph(node) => {
let flat = flatten_inline_prose(
flatten_statements(node.children_with_tokens().collect()),
cx,
false,
);
return Ir::concat(lower_prose_stream(flat.into_iter(), cx));
}
SyntaxKind::ENVIRONMENT
if !cx.in_dtx_doc_region
&& !has_verbatim_body(node)
&& is_margin_framed(node)
&& !is_math_env(node, cx) =>
{
return lower_margin_framed_environment(node, cx);
}
SyntaxKind::ENVIRONMENT
if !has_verbatim_body(node)
&& !cx.in_dtx_doc_region
&& is_math_env(node, cx)
&& !contains_doc_margin(node, cx) =>
{
return lower_math_environment(node, cx);
}
SyntaxKind::ENVIRONMENT
if !has_verbatim_body(node)
&& is_alignment_env(node, cx)
&& !contains_doc_margin(node, cx) =>
{
return lower_aligned_environment(node, cx);
}
SyntaxKind::ENVIRONMENT
if !has_verbatim_body(node)
&& is_list_env(node, cx)
&& (cx.wraps_prose() || !contains_doc_margin(node, cx)) =>
{
return lower_list_environment(node, cx);
}
SyntaxKind::ENVIRONMENT
if !has_verbatim_body(node)
&& !contains_doc_margin(node, cx)
&& body_has_top_level_ampersand(node) =>
{
return lower_aligned_environment(node, cx);
}
SyntaxKind::ENVIRONMENT if !has_verbatim_body(node) && !contains_doc_margin(node, cx) => {
return lower_environment(node, cx);
}
SyntaxKind::CONDITIONAL if !contains_doc_margin(node, cx) => {
return lower_conditional(node, cx);
}
SyntaxKind::COMMAND
if (command_has_math_arg(node, cx)
|| (cx.wraps_prose() || in_algorithm2e_env(node, cx))
&& command_has_managed_arg(node, cx))
&& !contains_doc_margin(node, cx) =>
{
return lower_command(node, cx);
}
SyntaxKind::INLINE_MATH if !contains_doc_margin(node, cx) => {
return lower_math(node, cx);
}
SyntaxKind::DISPLAY_MATH if !contains_doc_margin(node, cx) => {
return lower_display_math(node, cx);
}
SyntaxKind::MATH if !cx.in_dtx_doc_region && !contains_doc_margin(node, cx) => {
return lower_math_body(node, cx);
}
SyntaxKind::GROUP if !contains_doc_margin(node, cx) => {
if opaque_group_has_glued_environment_sibling(node) {
return Ir::verbatim(node.text().to_string());
}
if super::beamer::is_body_group(node) {
return lower_beamer_body(node, cx);
}
if matches!(cx.wrap, WrapMode::Reflow) && !doc_margin_opens_line(node, cx) {
return lower_opaque_group(node, cx);
}
if spans_multiple_lines(node) {
return lower_bracketed(node, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx, false);
}
}
SyntaxKind::OPTIONAL if !contains_doc_margin(node, cx) => {
if let Some(ir) = lower_optional(node, cx, false) {
return ir;
}
}
SyntaxKind::ROOT => return lower_root(node, cx),
_ => {}
}
Ir::concat(lower_element_stream(node.children_with_tokens(), cx))
}
fn lower_root(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let mut elements = node.children_with_tokens().peekable();
while let Some(SyntaxElement::Token(token)) = elements.peek() {
if token.kind() != SyntaxKind::WHITESPACE || cx.suppressed(token.text_range()) {
break;
}
elements.next();
}
Ir::concat(lower_element_stream(elements, cx))
}
fn lower_paragraph_reflow(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
reflow_elements(
node.children_with_tokens(),
cx,
paragraph_reflow_kind(node, cx),
)
}
fn paragraph_reflow_kind(node: &SyntaxNode, cx: LowerCtx<'_>) -> ReflowKind {
if in_algorithm2e_env(node, cx) {
ReflowKind::Algorithm2e
} else if in_statement_body_env(node, cx) {
ReflowKind::Statement
} else if node.parent().is_some_and(|parent| {
parent.kind() == SyntaxKind::ENVIRONMENT
&& (is_alignment_env(&parent, cx) || body_has_top_level_ampersand(&parent))
}) {
ReflowKind::AlignmentBody
} else {
ReflowKind::Prose
}
}
fn is_dtx_doc_paragraph(node: &SyntaxNode) -> bool {
let margin_inside = node
.children_with_tokens()
.filter_map(|e| e.into_token())
.find(|t| !is_collapsible_trivia(t.kind()))
.is_some_and(|t| t.kind() == SyntaxKind::DOC_MARGIN);
margin_inside
|| node
.first_token()
.is_some_and(|t| margin_precedes_on_line(&t))
}
fn dtx_paragraph_starts_margined(node: &SyntaxNode) -> bool {
node.descendants_with_tokens()
.filter_map(|e| e.into_token())
.find(|t| !is_collapsible_trivia(t.kind()))
.is_some_and(|t| t.kind() == SyntaxKind::DOC_MARGIN || margin_precedes_on_line(&t))
}
fn dtx_doc_region(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if !cx.is_dtx
|| cx.in_dtx_doc_region
|| node.kind() != SyntaxKind::ENVIRONMENT
|| has_verbatim_body(node)
|| node
.descendants()
.filter_map(Environment::cast)
.any(|env| matches!(env.name().as_deref(), Some("verbatim" | "verbatim*")))
|| node.text().to_string().contains("\\begin{verbatim")
|| node
.descendants()
.filter(|child| child.kind() == SyntaxKind::BEGIN)
.any(|begin| {
begin.descendants_with_tokens().any(|element| {
element
.into_token()
.is_some_and(|token| token.kind() == SyntaxKind::NEWLINE)
})
})
|| node.descendants_with_tokens().any(|element| {
element.into_token().is_some_and(|token| {
matches!(token.kind(), SyntaxKind::GUARD | SyntaxKind::COMMENT)
})
})
|| Environment::cast(node.clone()).is_some_and(|environment| {
matches!(
environment.name().as_deref(),
Some("macrocode" | "macrocode*")
)
})
{
return false;
}
let Some(first) = node.first_token() else {
return false;
};
let first_is_margined =
first.kind() == SyntaxKind::DOC_MARGIN || line_prefix_is_doc_margin(first.prev_token());
if !first_is_margined {
return false;
}
let mut next = node.last_token().and_then(|token| token.next_token());
while let Some(token) = next {
match token.kind() {
SyntaxKind::WHITESPACE => next = token.next_token(),
SyntaxKind::NEWLINE => break,
_ => return false,
}
}
let tokens: Vec<SyntaxToken> = node
.descendants_with_tokens()
.filter_map(SyntaxElement::into_token)
.collect();
tokens.iter().enumerate().all(|(index, token)| {
token.kind() != SyntaxKind::NEWLINE
|| tokens
.get(index + 1)
.is_some_and(|next| next.kind() == SyntaxKind::DOC_MARGIN)
})
}
fn environment_begin_has_newline(node: &SyntaxNode) -> bool {
Environment::cast(node.clone())
.and_then(|environment| environment.begin())
.is_some_and(|begin| {
begin.syntax().descendants_with_tokens().any(|element| {
element
.into_token()
.is_some_and(|token| token.kind() == SyntaxKind::NEWLINE)
})
})
}
fn line_prefix_is_doc_margin(mut token: Option<SyntaxToken>) -> bool {
while let Some(current) = token {
match current.kind() {
SyntaxKind::WHITESPACE => token = current.prev_token(),
SyntaxKind::DOC_MARGIN => return true,
_ => return false,
}
}
false
}
fn margin_starts_dtx_doc_region(margin: &SyntaxToken, cx: LowerCtx<'_>) -> bool {
if margin.kind() != SyntaxKind::DOC_MARGIN || cx.in_dtx_doc_region {
return false;
}
let mut next = margin.next_sibling_or_token();
while let Some(SyntaxElement::Token(token)) = &next {
if token.kind() == SyntaxKind::WHITESPACE {
next = token.next_sibling_or_token();
} else {
break;
}
}
let Some(SyntaxElement::Node(node)) = next else {
return false;
};
if dtx_doc_region(&node, cx) {
return true;
}
if node.kind() != SyntaxKind::PARAGRAPH {
return false;
}
node.children_with_tokens()
.find(|element| {
!matches!(
element,
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind())
)
})
.and_then(SyntaxElement::into_node)
.is_some_and(|child| dtx_doc_region(&child, cx))
}
fn is_indented_dtx_comment(comment: &SyntaxToken) -> bool {
comment.kind() == SyntaxKind::COMMENT
&& comment
.prev_token()
.filter(|previous| previous.kind() == SyntaxKind::WHITESPACE)
.and_then(|whitespace| whitespace.prev_token())
.is_some_and(|previous| previous.kind() == SyntaxKind::NEWLINE)
}
fn contains_indented_dtx_comment(node: &SyntaxNode) -> bool {
node.descendants_with_tokens()
.filter_map(SyntaxElement::into_token)
.any(|comment| is_indented_dtx_comment(&comment))
}
fn leading_indented_dtx_comment_padding(node: &SyntaxNode) -> Option<String> {
let comment = node.first_token()?;
if !is_indented_dtx_comment(&comment) {
return None;
}
comment
.prev_token()
.filter(|previous| previous.kind() == SyntaxKind::WHITESPACE)
.map(|whitespace| whitespace.text().to_string())
}
fn inside_macrocode(node: &SyntaxNode) -> bool {
node.ancestors()
.filter_map(Environment::cast)
.any(|environment| {
matches!(
environment.name().as_deref(),
Some("macrocode" | "macrocode*")
)
})
}
fn doc_margin_opens_line(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if !cx.is_dtx || cx.in_dtx_doc_region {
return false;
}
let mut prev = node.first_token().and_then(|t| t.prev_token());
while let Some(t) = prev {
match t.kind() {
SyntaxKind::NEWLINE => return false,
SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD => return true,
_ => prev = t.prev_token(),
}
}
false
}
fn margin_precedes_on_line(token: &SyntaxToken) -> bool {
let mut prev = token.prev_token();
while let Some(t) = prev {
match t.kind() {
SyntaxKind::WHITESPACE => prev = t.prev_token(),
SyntaxKind::DOC_MARGIN => return true,
_ => return false,
}
}
false
}
fn margin_floats_into_paragraph(margin: &SyntaxToken, cx: LowerCtx<'_>) -> bool {
let mut next = margin.next_sibling_or_token();
while let Some(SyntaxElement::Token(t)) = &next {
if t.kind() == SyntaxKind::WHITESPACE {
next = t.next_sibling_or_token();
} else {
break;
}
}
matches!(
next,
Some(SyntaxElement::Node(n))
if n.kind() == SyntaxKind::PARAGRAPH
&& is_dtx_doc_paragraph(&n)
&& dtx_doc_paragraph_reflows_safely(&n, cx)
)
}
fn lower_dtx_doc_paragraph(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
if dtx_doc_paragraph_reflows_safely(node, cx) {
reflow_elements(node.children_with_tokens(), cx, ReflowKind::DtxProse)
} else {
let preserve = LowerCtx {
preserve_dtx_nested_layout: true,
..cx
};
Ir::concat(lower_element_stream(node.children_with_tokens(), preserve))
}
}
fn dtx_doc_paragraph_reflows_safely(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if !dtx_paragraph_reflows(node, cx) || !dtx_paragraph_starts_margined(node) {
return false;
}
if let Some(&answer) = cx.dtx_reflow_cache.borrow().get(node) {
return answer;
}
let nested: Vec<SyntaxNode> = node
.descendants()
.filter(|d| d != node && d.kind() == SyntaxKind::PARAGRAPH && is_dtx_doc_paragraph(d))
.collect();
for descendant in nested.into_iter().rev() {
dtx_doc_paragraph_reflows_safely(&descendant, cx);
}
let probe = LowerCtx {
dtx_margin_probe: true,
..cx
};
let (_, margin_escaped) =
reflow_elements_checked(node.children_with_tokens(), probe, ReflowKind::DtxProse);
let answer = !margin_escaped;
cx.dtx_reflow_cache
.borrow_mut()
.insert(node.clone(), answer);
answer
}
fn dtx_paragraph_reflows(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
!node
.ancestors()
.any(|ancestor| ancestor.kind() == SyntaxKind::ENVIRONMENT)
&& node.children().all(|child| {
if child.kind() == SyntaxKind::ENVIRONMENT {
dtx_doc_region(&child, cx)
} else {
!child
.descendants()
.any(|descendant| descendant.kind() == SyntaxKind::ENVIRONMENT)
}
})
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum ReflowKind {
Prose,
AlignmentBody,
ProseArg,
Algorithm2e,
Statement,
StatementInterior,
DtxProse,
}
const DTX_DOC_MARGIN: &str = "% ";
#[derive(Clone, Copy)]
struct CitationSuffix {
start: usize,
placement: CitationPlacement,
}
struct RunAtom {
ir: Ir,
text: String,
trailing_citation: Option<CitationSuffix>,
preferred_break_before: bool,
}
#[derive(Clone, Copy)]
enum RunRender<'a> {
Fill,
Stable { target: usize },
Sentence(ResolvedProfile<'a>),
Semantic(ResolvedProfile<'a>),
}
fn render_sentences(run: Vec<RunAtom>, profile: ResolvedProfile<'_>, fill: bool) -> Ir {
let n = run.len();
let mut break_after = vec![false; n];
for i in 0..n.saturating_sub(1) {
let boundary_at_end = is_sentence_boundary_text(
&run[i].text,
Some(run[i + 1].text.as_str()),
true,
false,
profile,
);
let boundary_before_glued_citation = run[i]
.trailing_citation
.filter(|suffix| suffix.start > 0)
.is_some_and(|suffix| {
let before_citation = run[i].text[..suffix.start]
.strip_suffix('~')
.unwrap_or(&run[i].text[..suffix.start]);
is_sentence_boundary_text(
before_citation,
Some(&run[i].text[suffix.start..]),
true,
false,
profile,
)
});
if !(boundary_at_end || boundary_before_glued_citation) {
continue;
}
let mut sentence_end = i;
while run.get(sentence_end + 1).is_some_and(|atom| {
atom.trailing_citation.is_some_and(|suffix| {
suffix.start == 0
&& match suffix.placement {
CitationPlacement::Postpositive => true,
CitationPlacement::Ambiguous => !atom.preferred_break_before,
CitationPlacement::Textual => false,
}
})
}) {
sentence_end += 1;
}
break_after[sentence_end] = sentence_end + 1 < n;
}
let mut sentences: Vec<Ir> = Vec::new();
let mut current: Vec<Ir> = Vec::new();
let render_sentence = |atoms: Vec<Ir>| {
if fill {
Ir::fill(atoms)
} else {
Ir::join(Ir::text(" "), atoms)
}
};
for (i, atom) in run.into_iter().enumerate() {
current.push(atom.ir);
if break_after[i] {
sentences.push(render_sentence(std::mem::take(&mut current)));
}
}
if !current.is_empty() {
sentences.push(render_sentence(current));
}
Ir::join(
if fill {
Ir::preserved_line()
} else {
Ir::hard_line()
},
sentences,
)
}
struct LineBuilder<'a> {
atom: Vec<Ir>,
atom_text: String,
atom_trailing_citation: Option<CitationSuffix>,
preferred_break_before_next: bool,
run: Vec<RunAtom>,
lines: Vec<Ir>,
line_tail: Vec<Ir>,
seps: Vec<Ir>,
pending_sep: Ir,
margin: Option<&'static str>,
margin_escaped: bool,
render: RunRender<'a>,
}
impl<'a> LineBuilder<'a> {
fn new(margin: Option<&'static str>, render: RunRender<'a>) -> Self {
Self {
atom: Vec::new(),
atom_text: String::new(),
atom_trailing_citation: None,
preferred_break_before_next: false,
run: Vec::new(),
lines: Vec::new(),
line_tail: Vec::new(),
seps: Vec::new(),
pending_sep: Ir::hard_line(),
margin,
margin_escaped: false,
render,
}
}
fn note_margin_escape(&mut self) {
if self.margin.is_some() {
self.margin_escaped = true;
}
}
fn push_atom_piece(&mut self, ir: Ir, text: &str) {
self.atom.push(ir);
self.atom_text.push_str(text);
self.atom_trailing_citation = None;
}
fn push_trailing_citation(&mut self, ir: Ir, text: &str, placement: CitationPlacement) {
self.atom_trailing_citation.get_or_insert(CitationSuffix {
start: self.atom_text.len(),
placement,
});
self.atom.push(ir);
self.atom_text.push_str(text);
}
fn flush_atom(&mut self) {
if !self.atom.is_empty() {
let text = std::mem::take(&mut self.atom_text);
let ir = if self.margin.is_some() {
self.atom.clear();
Ir::verbatim(text.clone())
} else {
Ir::concat(self.atom.drain(..))
};
self.run.push(RunAtom {
ir,
text,
trailing_citation: self.atom_trailing_citation.take(),
preferred_break_before: std::mem::take(&mut self.preferred_break_before_next),
});
}
}
fn prefer_next_break(&mut self) {
if !self.run.is_empty() {
self.preferred_break_before_next = true;
}
}
fn push_segment(&mut self, content: Ir) {
self.seal_last_line();
self.seps
.push(std::mem::replace(&mut self.pending_sep, Ir::hard_line()));
self.lines.push(content);
}
fn separate_section(&mut self) {
self.pending_sep = if self.margin.is_some() {
Ir::concat([Ir::hard_line(), Ir::column_zero("%"), Ir::hard_line()])
} else {
Ir::empty_line()
};
}
fn push_margined_block(&mut self, ir: Ir) {
let margin = self.margin.expect("only called under `.dtx` prose reflow");
self.push_segment(Ir::concat([Ir::column_zero(margin), ir]));
}
fn append_trailing_comment(&mut self, text: &str) {
if !self.atom.is_empty() {
self.push_atom_piece(Ir::verbatim(text), text);
return;
}
if let Some(last) = self.run.last_mut() {
let prev = std::mem::replace(&mut last.ir, Ir::Nil);
last.ir = Ir::concat([prev, Ir::verbatim(" "), Ir::verbatim(text)]);
last.text.push(' ');
last.text.push_str(text);
return;
}
self.push_atom_piece(Ir::verbatim(text), text);
}
fn append_to_last_line(&mut self, ir: Ir) {
if !self.lines.is_empty() {
self.line_tail.push(ir);
}
}
fn seal_last_line(&mut self) {
if self.line_tail.is_empty() {
return;
}
let tail = std::mem::take(&mut self.line_tail);
if let Some(last) = self.lines.last_mut() {
let prev = std::mem::replace(last, Ir::Nil);
*last = Ir::concat(std::iter::once(prev).chain(tail));
}
}
fn end_line(&mut self) {
self.flush_atom();
if self.run.is_empty() {
return;
}
let run = std::mem::take(&mut self.run);
let body = self.render_run(run);
let segment = match self.margin {
Some(m) => Ir::margin_prefix(m, body),
None => body,
};
self.push_segment(segment);
}
fn end_hug_line(&mut self) {
self.flush_atom();
if self.run.is_empty() {
return;
}
let atoms: Vec<Ir> = std::mem::take(&mut self.run)
.into_iter()
.map(|atom| atom.ir)
.collect();
let body = if atoms.len() == 1 {
atoms.into_iter().next().unwrap()
} else {
let mut parts = Vec::with_capacity(atoms.len() * 2 - 1);
for (index, atom) in atoms.into_iter().enumerate() {
if index > 0 {
parts.push(Ir::Line);
}
parts.push(atom);
}
Ir::HugFill(parts.into())
};
let segment = match self.margin {
Some(margin) => Ir::margin_prefix(margin, body),
None => body,
};
self.push_segment(segment);
}
fn render_run(&self, run: Vec<RunAtom>) -> Ir {
match self.render {
RunRender::Fill => Ir::fill(run.into_iter().map(|a| a.ir)),
RunRender::Stable { target } => {
let preferred: Vec<bool> = run
.iter()
.skip(1)
.map(|atom| atom.preferred_break_before)
.collect();
Ir::preferred_fill(run.into_iter().map(|a| a.ir), preferred, target)
}
RunRender::Sentence(profile) => render_sentences(run, profile, false),
RunRender::Semantic(profile) => render_sentences(run, profile, true),
}
}
fn finish(mut self) -> Ir {
self.end_line();
self.seal_last_line();
let mut result: Vec<Ir> = Vec::with_capacity(self.lines.len().saturating_mul(2));
for (i, line) in self.lines.into_iter().enumerate() {
if i > 0 {
result.push(self.seps[i].clone());
}
result.push(line);
}
Ir::concat(result)
}
}
fn reflow_elements(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
kind: ReflowKind,
) -> Ir {
reflow_elements_checked(elements, cx, kind).0
}
fn reflow_elements_checked(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
kind: ReflowKind,
) -> (Ir, bool) {
let structural = kind == ReflowKind::Statement && cx.wrap == WrapMode::Reflow;
let elements: Vec<SyntaxElement> = elements.collect();
let elements = if structural {
elements
} else {
flatten_statements(elements)
};
let glue_matched_args = !cx.in_dtx_doc_region
&& !run_carries_doc_margin(&elements, cx)
&& matches!(
kind,
ReflowKind::Prose | ReflowKind::ProseArg | ReflowKind::AlignmentBody
);
let elements: Vec<SyntaxElement> = if kind == ReflowKind::Algorithm2e {
elements
} else {
flatten_inline_prose(elements, cx, glue_matched_args)
};
let unit_glue: Option<Vec<bool>> =
(kind == ReflowKind::StatementInterior).then(|| statement_glue(&elements));
let margin: Option<&'static str> = (kind == ReflowKind::DtxProse).then_some(DTX_DOC_MARGIN);
let render = match cx.wrap {
_ if kind == ReflowKind::Algorithm2e => RunRender::Fill,
WrapMode::Stable if kind != ReflowKind::Statement => RunRender::Stable {
target: cx.stable_target,
},
WrapMode::Sentence if kind != ReflowKind::Statement => RunRender::Sentence(cx.profile),
WrapMode::Semantic if kind != ReflowKind::Statement => RunRender::Semantic(cx.profile),
_ => RunRender::Fill,
};
let mut b = LineBuilder::new(margin, render);
let mut line_all_commands = true;
let mut line_has_content = false;
let mut line_margined = true;
let mut prev_was_block = false;
let mut block_gap = false;
let mut prev_block_closes_line = false;
let mut idx = 0;
while idx < elements.len() {
let after_block = std::mem::take(&mut prev_was_block);
let after_block_gap = std::mem::take(&mut block_gap);
let after_block_closed = std::mem::take(&mut prev_block_closes_line);
match &elements[idx] {
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
let newlines = consume_widened_gap_slice(&elements, &mut idx);
if newlines < 2
&& let Some(glue) = &unit_glue
&& glue.get(idx).copied().unwrap_or(false)
{
if after_block {
prev_was_block = true;
block_gap = true;
prev_block_closes_line = after_block_closed;
} else {
b.push_atom_piece(Ir::verbatim(" "), " ");
}
continue;
}
if newlines >= 2 {
b.end_line();
b.pending_sep = Ir::empty_line();
line_all_commands = true;
line_has_content = false;
line_margined = false;
} else if newlines == 1 {
let residue_applies = !matches!(
kind,
ReflowKind::ProseArg
| ReflowKind::StatementInterior
| ReflowKind::Algorithm2e
| ReflowKind::AlignmentBody
);
let prev_is_command = residue_applies && line_has_content && line_all_commands;
let next_is_command =
residue_applies && line_is_command_only(&elements, idx, cx);
if kind == ReflowKind::Statement
|| cx.wrap == WrapMode::Preserve
|| cx.wrap == WrapMode::Semantic
|| prev_is_command
|| next_is_command
{
b.end_line();
if cx.wrap == WrapMode::Semantic
&& kind != ReflowKind::Statement
&& line_has_content
{
b.pending_sep = Ir::preserved_line();
}
} else {
b.flush_atom();
b.prefer_next_break();
}
line_all_commands = true;
line_has_content = false;
line_margined = false;
} else {
b.flush_atom();
if after_block {
prev_was_block = true;
block_gap = true;
prev_block_closes_line = after_block_closed;
}
}
continue;
}
SyntaxElement::Token(token)
if kind == ReflowKind::Algorithm2e
&& token.kind() == SyntaxKind::CONTROL_SYMBOL
&& token.text() == "\\;" =>
{
if after_block && !after_block_closed {
b.append_to_last_line(ride_after_block(lower_loose_token(token, cx), after_block_gap));
} else {
b.push_atom_piece(lower_loose_token(token, cx), token.text());
}
b.end_line();
line_all_commands = true;
line_has_content = false;
prev_was_block = true;
prev_block_closes_line = true;
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => {
if after_block {
let comment = if after_block_gap {
Ir::concat([Ir::verbatim(" "), Ir::verbatim(token.text())])
} else {
Ir::verbatim(token.text())
};
b.append_to_last_line(comment);
} else if line_has_content {
b.append_trailing_comment(token.text());
b.end_line();
} else {
b.end_line();
b.push_atom_piece(Ir::verbatim(token.text()), token.text());
b.end_line();
}
line_all_commands = true;
line_has_content = false;
}
SyntaxElement::Token(token)
if token.kind() == SyntaxKind::CONTROL_SYMBOL && token.text().contains('\n') =>
{
let before = token.text().split_once('\n').map(|(b, _)| b).unwrap_or("");
if !before.is_empty() {
b.push_atom_piece(Ir::verbatim(before), before);
}
if !cx.absorbs_control_newline(token) {
b.end_line();
}
line_all_commands = true;
line_has_content = false;
}
SyntaxElement::Token(token)
if margin.is_some() && token.kind() == SyntaxKind::DOC_MARGIN =>
{
line_margined = true;
}
SyntaxElement::Token(token)
if cx.in_dtx_doc_region && token.kind() == SyntaxKind::DOC_MARGIN =>
{
while elements.get(idx + 1).is_some_and(|element| {
matches!(element, SyntaxElement::Token(next) if next.kind() == SyntaxKind::WHITESPACE)
}) {
idx += 1;
}
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::GUARD => {
if let Some(line) = collect_guard_line(&elements, &mut idx, cx) {
b.end_line();
b.push_segment(line);
line_all_commands = true;
line_has_content = false;
continue;
}
if margin.is_some() {
b.note_margin_escape();
}
b.push_atom_piece(lower_loose_token(token, cx), token.text());
line_has_content = true;
line_all_commands = false;
}
SyntaxElement::Token(token) => {
if after_block && !after_block_closed {
b.append_to_last_line(ride_after_block(
lower_loose_token(token, cx),
after_block_gap,
));
prev_was_block = true;
} else {
b.push_atom_piece(lower_loose_token(token, cx), token.text());
}
line_has_content = true;
line_all_commands = false;
}
SyntaxElement::Node(child) if child.kind() == SyntaxKind::STATEMENT => {
let ir = lower_statement(child, cx);
b.end_line();
b.push_segment(ir);
line_all_commands = true;
line_has_content = false;
prev_was_block = true;
prev_block_closes_line = true;
}
SyntaxElement::Node(child) if child.kind() == SyntaxKind::LINE_BREAK => {
b.push_atom_piece(lower_node(child, cx), &child.text().to_string());
b.end_line();
line_all_commands = true;
line_has_content = false;
}
SyntaxElement::Node(child)
if matches!(cx.wrap, WrapMode::Reflow | WrapMode::Stable)
&& margin.is_none()
&& !after_block
&& child.kind() == SyntaxKind::COMMAND
&& command_is_inline(child, cx)
&& inline_token_list_atoms(child, cx).is_some() =>
{
let atoms = inline_token_list_atoms(child, cx)
.expect("match guard proved the inline token list");
for (index, atom) in atoms.into_iter().enumerate() {
if index > 0 {
b.flush_atom();
}
b.push_atom_piece(atom, "");
}
line_has_content = true;
line_all_commands = false;
idx += 1;
continue;
}
SyntaxElement::Node(child) => {
let (ir, source) = if let Some(last) = super::beamer::wrapper_end(&elements, idx)
&& !run_carries_doc_margin(&elements[idx..=last], cx)
{
let wrapper = &elements[idx..=last];
let ir = Ir::concat(lower_element_stream(wrapper.iter().cloned(), cx));
let source = wrapper.iter().map(ToString::to_string).collect::<String>();
idx = last;
(ir, source)
} else {
(lower_node(child, cx), child.text().to_string())
};
let is_sectioning =
child.kind() == SyntaxKind::COMMAND && command_is_sectioning(child, cx);
let is_section_boundary = is_sectioning
&& child
.parent()
.is_some_and(|parent| parent.kind() == SyntaxKind::PARAGRAPH);
let is_section_label = child.kind() == SyntaxKind::COMMAND
&& command_is_label(child)
&& label_follows_sectioning_run(&elements, idx, cx);
let section_label_closes_line =
is_section_label && next_is_separated(&elements, idx);
let algorithm_block = kind == ReflowKind::Algorithm2e
&& cx.signatures.command_at(child).is_some_and(|sig| {
sig.args.iter().any(|arg| arg.content == ContentKind::Algorithm2e)
});
let is_block_stmt = kind != ReflowKind::Statement
&& child.kind() == SyntaxKind::COMMAND
&& (is_sectioning
|| (command_is_block(child, cx)
&& b.atom.is_empty()
&& (next_is_separated(&elements, idx) || algorithm_block)));
if is_section_label && !ir.contains_forced_break() {
let glued_to_previous_label = idx > 0
&& matches!(
&elements[idx - 1],
SyntaxElement::Node(previous)
if previous.kind() == SyntaxKind::COMMAND
&& command_is_label(previous)
);
if !glued_to_previous_label {
b.end_line();
}
b.push_atom_piece(ir, &source);
if section_label_closes_line {
b.end_line();
if next_nontrivia_is_label(&elements, idx, cx) {
b.pending_sep = Ir::hard_line();
} else {
b.separate_section();
}
line_has_content = false;
prev_was_block = true;
prev_block_closes_line = true;
} else {
line_has_content = true;
}
line_all_commands = true;
idx += 1;
continue;
}
if is_block_stmt && !ir.contains_forced_break() {
b.end_line();
if is_section_boundary {
b.separate_section();
}
b.push_atom_piece(ir, &source);
b.end_line();
if is_section_boundary && !next_nontrivia_is_label(&elements, idx, cx) {
b.separate_section();
}
line_all_commands = true;
line_has_content = false;
prev_was_block = true;
prev_block_closes_line = true;
idx += 1;
continue;
}
if ir.contains_forced_break() {
if is_section_boundary {
b.end_line();
b.separate_section();
}
let owns_dtx_margin =
margin.is_some() && dtx_doc_region(child, cx);
let frame_lead = (margin.is_some()
&& line_margined
&& !line_has_content
&& is_margin_framed_macrocode(child))
.then(|| dtx_env_line_lead(child))
.flatten();
let hugs_preceding_prose = margin.is_none()
&& child.kind() == SyntaxKind::INLINE_MATH
&& line_has_content
&& matches!(kind, ReflowKind::Prose | ReflowKind::ProseArg | ReflowKind::AlignmentBody)
&& matches!(b.render, RunRender::Fill);
let rides_preceding_block = after_block
&& !after_block_gap
&& !after_block_closed
&& !is_sectioning;
if rides_preceding_block {
b.append_to_last_line(ir);
} else if margin.is_none() && (!b.atom.is_empty() || hugs_preceding_prose) {
b.push_atom_piece(ir, &source);
if hugs_preceding_prose {
b.end_hug_line();
} else {
b.end_line();
}
} else if let Some(lead) = frame_lead {
b.end_line();
b.push_segment(Ir::concat([lead, ir]));
} else if owns_dtx_margin {
b.end_line();
b.push_segment(ir);
} else if margin.is_some() && line_margined && block_rides_own_margins(child) {
b.end_line();
b.push_margined_block(ir);
} else {
b.end_line();
b.note_margin_escape();
b.push_segment(ir);
}
line_all_commands = true;
line_has_content = false;
prev_was_block = true;
let display_math_closes_prose = child.kind() == SyntaxKind::DISPLAY_MATH
&& matches!(kind, ReflowKind::Prose | ReflowKind::ProseArg | ReflowKind::AlignmentBody);
let environment_closes_line = child.kind() == SyntaxKind::ENVIRONMENT
&& !cx.signatures.environment_at(child).is_some_and(|sig| sig.inline);
prev_block_closes_line = is_block_stmt
|| section_label_closes_line
|| environment_closes_line
|| display_math_closes_prose;
if is_section_boundary && !next_nontrivia_is_label(&elements, idx, cx) {
b.separate_section();
} else if section_label_closes_line {
if next_nontrivia_is_label(&elements, idx, cx) {
b.pending_sep = Ir::hard_line();
} else {
b.separate_section();
}
}
} else {
if after_block && !after_block_closed {
b.append_to_last_line(ride_after_block(ir, after_block_gap));
prev_was_block = true;
} else if child.kind() == SyntaxKind::COMMAND
&& let Some(placement) = command_citation_placement(child, cx)
&& placement != CitationPlacement::Textual
{
b.push_trailing_citation(ir, &source, placement);
} else {
b.push_atom_piece(ir, &source);
}
line_has_content = true;
line_all_commands &=
child.kind() == SyntaxKind::COMMAND && !command_is_inline(child, cx);
}
}
}
idx += 1;
}
let escaped = b.margin_escaped;
(b.finish(), escaped)
}
fn collect_guard_line(elements: &[SyntaxElement], idx: &mut usize, cx: LowerCtx<'_>) -> Option<Ir> {
let mut end = *idx;
while let Some(element) = elements.get(end) {
let spans_lines = match element {
SyntaxElement::Token(t) => t.text().contains('\n'),
SyntaxElement::Node(n) => n.text().contains_char('\n'),
};
if spans_lines {
if matches!(element, SyntaxElement::Token(t) if is_collapsible_trivia(t.kind())) {
break;
}
return None;
}
end += 1;
}
let mut last = end;
while last > *idx
&& matches!(&elements[last - 1], SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()))
{
last -= 1;
}
let ir = Ir::concat(lower_element_stream(
elements[*idx..last].iter().cloned(),
cx,
));
if ir.contains_forced_break() {
return None;
}
*idx = end;
Some(ir)
}
fn ride_after_block(ir: Ir, gap: bool) -> Ir {
if gap {
Ir::concat([Ir::verbatim(" "), ir])
} else {
ir
}
}
fn run_carries_doc_margin(run: &[SyntaxElement], cx: LowerCtx<'_>) -> bool {
if !cx.is_dtx {
return false;
}
run.iter().any(|element| match element {
SyntaxElement::Token(t) => {
matches!(t.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD)
}
SyntaxElement::Node(n) => contains_doc_margin(n, cx),
})
}
fn dtx_run_starts_margined(run: &[SyntaxElement]) -> bool {
for element in run {
let first = match element {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => continue,
SyntaxElement::Token(t) => Some(t.clone()),
SyntaxElement::Node(n) => n
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.find(|t| !is_collapsible_trivia(t.kind())),
};
if let Some(token) = first {
return token.kind() == SyntaxKind::DOC_MARGIN;
}
}
false
}
fn dtx_run_reflows_safely(run: &[SyntaxElement], cx: LowerCtx<'_>) -> bool {
if !dtx_run_starts_margined(run) {
return false;
}
let structured = run.iter().any(|element| match element {
SyntaxElement::Node(n) if is_margin_framed_macrocode(n) => false,
SyntaxElement::Node(n) => n.descendants().any(|d| d.kind() == SyntaxKind::ENVIRONMENT),
SyntaxElement::Token(_) => false,
}) || run
.first()
.and_then(SyntaxElement::parent)
.is_some_and(|p| p.ancestors().any(|a| a.kind() == SyntaxKind::ENVIRONMENT));
if structured {
return false;
}
let probe = LowerCtx {
dtx_margin_probe: true,
..cx
};
!reflow_elements_checked(run.iter().cloned(), probe, ReflowKind::DtxProse).1
}
fn is_margin_framed_macrocode(node: &SyntaxNode) -> bool {
node.kind() == SyntaxKind::ENVIRONMENT
&& Environment::cast(node.clone())
.is_some_and(|e| matches!(e.name().as_deref(), Some("macrocode" | "macrocode*")))
&& is_margin_framed(node)
}
fn is_expl_syntax_off_command(element: &SyntaxElement) -> bool {
let SyntaxElement::Node(command) = element else {
return false;
};
command.kind() == SyntaxKind::COMMAND
&& command.first_token().is_some_and(|token| {
token.kind() == SyntaxKind::CONTROL_WORD
&& expl_toggle(token.text()) == Some(ExplToggle::Off)
})
}
fn dtx_env_line_lead(node: &SyntaxNode) -> Option<Ir> {
let mut ws: Option<String> = None;
let mut prev = node.prev_sibling_or_token();
if let Some(SyntaxElement::Token(t)) = &prev
&& t.kind() == SyntaxKind::WHITESPACE
&& !t.text().contains('\n')
{
ws = Some(t.text().to_string());
prev = t.prev_sibling_or_token();
}
match prev {
Some(SyntaxElement::Token(t)) if t.kind() == SyntaxKind::DOC_MARGIN => {
let margin = Ir::column_zero(t.text());
Some(match ws {
Some(ws) => Ir::concat([margin, Ir::verbatim(ws)]),
None => margin,
})
}
_ => None,
}
}
fn lower_expl_paragraph(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let elements: Vec<SyntaxElement> = node.children_with_tokens().collect();
let mut segments: Vec<Ir> = Vec::new();
let mut seps: Vec<Ir> = Vec::new();
let mut i = 0;
while i < elements.len() {
let mut boundary_newlines = 0;
if !segments.is_empty() {
while i < elements.len() {
let SyntaxElement::Token(t) = &elements[i] else {
break;
};
if !is_collapsible_trivia(t.kind()) {
break;
}
boundary_newlines += t.text().matches('\n').count();
i += 1;
}
if i >= elements.len() {
break;
}
}
let in_region = cx.in_expl3_region(elements[i].text_range().start());
let start = i;
while i < elements.len()
&& cx.in_expl3_region(elements[i].text_range().start()) == in_region
{
i += 1;
}
if in_region
&& elements[start..i]
.iter()
.rev()
.find(|element| !is_collapsible_trivia_element(element))
.is_some_and(is_expl_syntax_off_command)
{
let mut comment = i;
while let Some(SyntaxElement::Token(token)) = elements.get(comment)
&& token.kind() == SyntaxKind::WHITESPACE
&& !token.text().contains(['\r', '\n'])
{
comment += 1;
}
if matches!(
elements.get(comment),
Some(SyntaxElement::Token(token)) if token.kind() == SyntaxKind::COMMENT
) {
i = comment + 1;
}
}
if i < elements.len() {
let mut end = i;
while end > start && is_collapsible_trivia_element(&elements[end - 1]) {
end -= 1;
}
if end > start {
i = end;
}
}
let run = &elements[start..i];
let guarded_text = (!in_region).then(|| {
let text = run.iter().map(ToString::to_string).collect::<String>();
text_is_fully_guarded(&text).then_some(text)
});
let ir = if let Some(text) = guarded_text.flatten() {
Ir::verbatim(text.trim_start_matches(['\r', '\n']))
} else if in_region {
lower_expl_code(run.iter().cloned(), cx, Statements::Structural)
} else if cx.wraps_prose() && !run_carries_doc_margin(run, cx) {
reflow_elements(run.iter().cloned(), cx, ReflowKind::Prose)
} else if cx.wraps_prose() && dtx_run_reflows_safely(run, cx) {
reflow_elements(run.iter().cloned(), cx, ReflowKind::DtxProse)
} else {
Ir::concat(lower_element_stream(run.iter().cloned(), cx))
};
if !matches!(ir, Ir::Nil) {
if !segments.is_empty() {
seps.push(if boundary_newlines >= 2 {
Ir::empty_line()
} else {
Ir::hard_line()
});
}
segments.push(ir);
}
}
let mut result = Vec::with_capacity(segments.len().saturating_mul(2));
for (n, seg) in segments.into_iter().enumerate() {
if n > 0 {
result.push(seps[n - 1].clone());
}
result.push(seg);
}
Ir::concat(result)
}
fn text_is_fully_guarded(text: &str) -> bool {
let mut content_lines = text.lines().filter(|line| !line.is_empty());
content_lines
.next()
.is_some_and(|line| line.starts_with("%<"))
&& content_lines.all(|line| line.starts_with("%<"))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Statements {
Structural,
Ignore,
}
fn lower_expl_code(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
statements: Statements,
) -> Ir {
let elements: Vec<SyntaxElement> = elements.collect();
let map = (statements == Statements::Structural).then(|| segment_expl_statements(&elements));
let mut lines: Vec<Ir> = Vec::new();
let mut seps: Vec<Ir> = Vec::new();
let mut pending_sep = Ir::hard_line();
let mut atom: Vec<Ir> = Vec::new();
let mut parts: Vec<Ir> = Vec::new();
let mut sep_before_next: Option<Ir> = None;
fn flush_atom(atom: &mut Vec<Ir>, parts: &mut Vec<Ir>, sep_before_next: &mut Option<Ir>) {
if atom.is_empty() {
return;
}
if !parts.is_empty() {
parts.push(sep_before_next.take().unwrap_or(Ir::Line));
}
parts.push(Ir::concat(atom.drain(..)));
*sep_before_next = None;
}
fn line_fill(mut parts: Vec<Ir>, sticky: bool) -> Ir {
if parts.len() == 1 {
return parts.drain(..).next().unwrap();
}
if sticky {
Ir::StickyFill(parts.into())
} else {
Ir::HugFill(parts.into())
}
}
fn commit_line(
atom: &mut Vec<Ir>,
parts: &mut Vec<Ir>,
sep_before_next: &mut Option<Ir>,
lines: &mut Vec<Ir>,
seps: &mut Vec<Ir>,
pending_sep: &mut Ir,
sticky: &mut bool,
) {
flush_atom(atom, parts, sep_before_next);
if !parts.is_empty() {
let line = line_fill(std::mem::take(parts), *sticky);
seps.push(std::mem::replace(pending_sep, Ir::hard_line()));
lines.push(line);
}
parts.clear();
*sep_before_next = None;
*sticky = true;
}
let mut after_block = false;
let mut line_sticky = true;
let mut idx = 0;
while idx < elements.len() {
if let Some(m) = map.as_ref()
&& (m.is_fallback(idx) || m.is_glued(idx))
{
line_sticky = false;
}
match &elements[idx] {
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
let run_start = idx;
let newlines = consume_widened_gap_slice(&elements, &mut idx);
let boundary = map
.as_ref()
.is_some_and(|m| run_start > 0 && m.boundary_after(run_start - 1));
if boundary {
after_block = false;
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
if newlines >= 2 {
pending_sep = Ir::empty_line();
}
} else {
if newlines >= 1 {
after_block = false;
}
flush_atom(&mut atom, &mut parts, &mut sep_before_next);
if sep_before_next.is_none() {
let bare_arg_glue = map.is_none() && elements.get(idx).is_some_and(|el| {
!matches!(
el,
SyntaxElement::Node(n)
if matches!(n.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL)
) && !matches!(
el,
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT
)
});
sep_before_next = Some(
if bare_arg_glue
|| map
.as_ref()
.is_some_and(|m| m.glue_before(idx) || m.is_glued(idx))
{
Ir::verbatim(" ")
} else {
Ir::Line
},
);
}
}
continue;
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::TILDE => {
after_block = false;
atom.push(Ir::verbatim(token.text()));
flush_atom(&mut atom, &mut parts, &mut sep_before_next);
let next = elements[idx + 1..]
.iter()
.position(|el| {
!matches!(el, SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()))
})
.map(|off| idx + 1 + off);
sep_before_next = Some(
if next.is_some_and(|n| {
map.as_ref()
.is_some_and(|m| m.glue_before(n) || m.is_glued(n))
}) {
Ir::Nil
} else {
Ir::SoftLine
},
);
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => {
if after_block {
let block = lines.pop().expect("after_block implies a pushed line");
let spaced = sep_before_next.take().is_some();
lines.push(Ir::concat(if spaced {
vec![block, Ir::verbatim(" "), Ir::verbatim(token.text())]
} else {
vec![block, Ir::verbatim(token.text())]
}));
after_block = false;
} else if atom.is_empty() && parts.is_empty() {
atom.push(Ir::verbatim(token.text()));
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
} else {
let spaced = atom.is_empty();
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
let line = lines
.pop()
.expect("trailing comment follows committed code");
let comment = if spaced {
format!(" {}", token.text())
} else {
token.text().to_string()
};
lines.push(Ir::concat(vec![line, Ir::zero_width(comment)]));
}
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::GUARD => {
after_block = false;
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
atom.push(lower_loose_token(token, cx));
}
SyntaxElement::Token(token) => {
after_block = false;
atom.push(lower_loose_token(token, cx));
}
SyntaxElement::Node(child)
if child.kind() == SyntaxKind::COMMAND
&& child
.first_child()
.is_some_and(|c| c.kind() == SyntaxKind::DOC_COMMENT) =>
{
after_block = false;
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
let mut rest: Vec<SyntaxElement> = Vec::new();
for el in child.children_with_tokens() {
match &el {
SyntaxElement::Node(n) if n.kind() == SyntaxKind::DOC_COMMENT => {
for t in n.children_with_tokens() {
if let SyntaxElement::Token(t) = t
&& t.kind() == SyntaxKind::COMMENT
{
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(Ir::verbatim(t.text()));
}
}
}
_ => rest.push(el.clone()),
}
}
let ir = lower_expl_code(rest.into_iter(), cx, Statements::Ignore);
if !matches!(ir, Ir::Nil) {
atom.push(ir);
}
}
SyntaxElement::Node(child) => {
after_block = false;
let in_glued = map.as_ref().is_some_and(|m| m.is_glued(idx));
if !in_glued
&& !atom.is_empty()
&& child.kind() == SyntaxKind::GROUP
&& expl_arg_takes_leading_space(child)
{
flush_atom(&mut atom, &mut parts, &mut sep_before_next);
sep_before_next = Some(Ir::Line);
}
if !in_glued
&& parts.is_empty()
&& atom.is_empty()
&& child.kind() == SyntaxKind::COMMAND
&& let Some((cond_ir, last)) = expl_conditional_at(&elements, idx, cx)
{
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(cond_ir);
after_block = true;
idx = last + 1;
continue;
}
let in_fallback = map.as_ref().is_some_and(|m| m.is_fallback(idx));
let statement_leading = parts.is_empty() && atom.is_empty();
if !in_glued
&& !in_fallback
&& !statement_leading
&& child.kind() == SyntaxKind::COMMAND
&& is_trailing_in_statement(&elements, idx, map.as_ref())
&& let Some(exploded) = command_name(child)
.and_then(|name| expl3::conditional_branches(&name))
.and_then(|n| lower_expl_conditional(child, cx, n))
{
let sep = if atom.is_empty() {
sep_before_next.take().unwrap_or(Ir::Line)
} else {
Ir::Nil
};
flush_atom(&mut atom, &mut parts, &mut sep_before_next);
let head = if parts.len() == 1 {
parts.drain(..).next().unwrap()
} else {
Ir::StickyFill(std::mem::take(&mut parts).into())
};
let flat = Ir::concat(vec![head.clone(), sep, lower_node(child, cx)]);
let broken = Ir::concat(vec![head, Ir::hard_line(), exploded]);
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(Ir::group(Ir::if_break(flat, broken)));
after_block = true;
idx += 1;
continue;
}
if child.kind() == SyntaxKind::GROUP
&& atom.is_empty()
&& !parts.is_empty()
&& !expl_group_forces_break(child)
&& expl_group_body_is_multi_atom(child)
&& is_trailing_in_statement(&elements, idx, map.as_ref())
&& !statement_has_preceding_group(&elements, idx, map.as_ref())
&& !head_command_has_grouped_sibling_arg(child)
&& let ExplGroupPieces::Pieces {
open_ir,
body,
close_ir,
spaced,
forced: false,
} = expl_group_pieces(child, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx)
&& !body.contains_forced_break()
{
let sep = sep_before_next.take().unwrap_or(Ir::Line);
flush_atom(&mut atom, &mut parts, &mut sep_before_next);
let head = if parts.len() == 1 {
parts.drain(..).next().unwrap()
} else {
Ir::StickyFill(std::mem::take(&mut parts).into())
};
let space = if spaced { Ir::verbatim(" ") } else { Ir::Nil };
let c_flat = Ir::concat(vec![
head.clone(),
sep,
open_ir.clone(),
space.clone(),
body.clone(),
space.clone(),
close_ir.clone(),
]);
let c_allman_inline = Ir::concat(vec![
head.clone(),
Ir::indent(Ir::concat(vec![
Ir::hard_line(),
open_ir.clone(),
space.clone(),
body.clone(),
space,
close_ir.clone(),
])),
]);
let c_allman_broken = Ir::concat(vec![
head,
Ir::indent(Ir::concat(vec![
Ir::hard_line(),
open_ir,
Ir::indent(Ir::concat(vec![Ir::hard_line(), body])),
Ir::hard_line(),
close_ir,
])),
]);
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(Ir::conditional_group_all_lines(vec![
c_flat,
c_allman_inline,
c_allman_broken,
]));
after_block = true;
idx += 1;
continue;
}
let hang_group = child.kind() == SyntaxKind::GROUP && atom.is_empty();
let starts_line = parts.is_empty();
let ir = lower_node(child, cx);
debug_assert!(
!in_fallback || !line_sticky,
"a fallback statement must commit as a hugging fill"
);
let forced_dispatch = !in_fallback && ir.contains_forced_break();
if in_glued {
atom.push(ir);
}
else if map.is_some()
&& child.kind() == SyntaxKind::COMMAND
&& atom.is_empty()
&& !parts.is_empty()
&& is_trailing_in_statement(&elements, idx, map.as_ref())
&& child.children().any(|c| c.kind() == SyntaxKind::GROUP)
{
let head = line_fill(std::mem::take(&mut parts), line_sticky);
let sep = match sep_before_next.take() {
Some(Ir::SoftLine) | Some(Ir::Nil) => Ir::Nil,
_ => Ir::verbatim(" "),
};
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(Ir::concat(vec![head, sep, ir]));
after_block = true;
} else if forced_dispatch {
if !atom.is_empty() {
atom.push(ir);
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
} else if hang_group {
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
if !lines.is_empty() {
let sep = std::mem::replace(&mut pending_sep, Ir::hard_line());
seps.push(Ir::Nil);
lines.push(Ir::indent(Ir::concat(vec![sep, ir])));
} else {
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(ir);
}
} else if !parts.is_empty() {
let head = line_fill(std::mem::take(&mut parts), line_sticky);
let sep = sep_before_next.take().unwrap_or(Ir::Line);
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(Ir::group_hug(Ir::concat(vec![head, sep, ir])));
} else {
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
seps.push(std::mem::replace(&mut pending_sep, Ir::hard_line()));
lines.push(ir);
}
after_block = true;
} else if hang_group && starts_line && !lines.is_empty() {
let sep = std::mem::replace(&mut pending_sep, Ir::Nil);
atom.push(Ir::indent(Ir::concat(vec![sep, ir])));
} else if hang_group && !starts_line {
sep_before_next = Some(Ir::Nil);
atom.push(Ir::indent(Ir::concat(vec![Ir::Line, ir])));
} else {
atom.push(ir);
}
}
}
if map.as_ref().is_some_and(|m| m.boundary_after(idx)) {
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
}
idx += 1;
}
commit_line(
&mut atom,
&mut parts,
&mut sep_before_next,
&mut lines,
&mut seps,
&mut pending_sep,
&mut line_sticky,
);
let mut result: Vec<Ir> = Vec::with_capacity(lines.len().saturating_mul(2));
for (i, line) in lines.into_iter().enumerate() {
if i > 0 {
result.push(seps[i].clone());
}
result.push(line);
}
Ir::concat(result)
}
fn expl_group_forces_break(node: &SyntaxNode) -> bool {
node.descendants_with_tokens()
.filter_map(SyntaxElement::into_token)
.any(|t| {
matches!(
t.kind(),
SyntaxKind::COMMENT | SyntaxKind::GUARD | SyntaxKind::DOC_MARGIN
)
})
}
fn expl_group_body_is_multi_atom(node: &SyntaxNode) -> bool {
node.children()
.filter(|n| n.kind() == SyntaxKind::COMMAND)
.count()
>= 2
}
fn is_simple_param_run(node: &SyntaxNode) -> bool {
let mut body: Vec<SyntaxToken> = Vec::new();
for element in node.children_with_tokens() {
match element {
SyntaxElement::Token(t) => match t.kind() {
SyntaxKind::L_BRACE
| SyntaxKind::R_BRACE
| SyntaxKind::L_BRACKET
| SyntaxKind::R_BRACKET => {}
_ => body.push(t),
},
SyntaxElement::Node(_) => return false,
}
}
let is_space =
|t: &SyntaxToken| matches!(t.kind(), SyntaxKind::WHITESPACE | SyntaxKind::NEWLINE);
while body.first().is_some_and(is_space) {
body.remove(0);
}
while body.last().is_some_and(is_space) {
body.pop();
}
let mut saw_hash = false;
let mut prev_hash = false;
for t in &body {
match t.kind() {
SyntaxKind::HASH => {
saw_hash = true;
prev_hash = true;
}
SyntaxKind::WORD if prev_hash && is_param_digit(t) => {
prev_hash = false;
}
_ => return false,
}
}
saw_hash
}
fn is_trailing_in_statement(
elements: &[SyntaxElement],
idx: usize,
map: Option<&StatementMap>,
) -> bool {
if let Some(m) = map
&& m.boundary_after(idx)
{
return true;
}
for element in &elements[idx + 1..] {
match element {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {}
_ => return false,
}
}
true
}
fn head_command_has_grouped_sibling_arg(child: &SyntaxNode) -> bool {
let Some(owner) = child.parent() else {
return false;
};
if owner.kind() != SyntaxKind::COMMAND {
return false;
}
let child_start = child.text_range().start();
owner
.children_with_tokens()
.take_while(|el| el.text_range().start() < child_start)
.any(|el| matches!(el.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL))
}
fn statement_has_preceding_group(
elements: &[SyntaxElement],
idx: usize,
map: Option<&StatementMap>,
) -> bool {
for j in (0..idx).rev() {
if let Some(m) = map
&& m.boundary_after(j)
{
return false;
}
match &elements[j] {
SyntaxElement::Node(n)
if matches!(n.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL) =>
{
return true;
}
_ => {}
}
}
false
}
fn expl_group_is_spaced(node: &SyntaxNode) -> bool {
if is_simple_param_run(node) {
return false;
}
let Some(parent) = node.parent() else {
return true;
};
if parent.kind() != SyntaxKind::COMMAND {
return true;
}
match command_name(&parent) {
Some(name) => name.contains('_') || name.contains(':'),
None => true,
}
}
fn expl_arg_takes_leading_space(node: &SyntaxNode) -> bool {
node.parent()
.filter(|parent| parent.kind() == SyntaxKind::COMMAND)
.and_then(|parent| command_name(&parent))
.is_some_and(|name| name.contains('_') || name.contains(':'))
}
fn lower_expl_group(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
) -> Ir {
let (open_ir, body, close_ir, spaced, has_comment) =
match expl_group_pieces(node, open, close, cx) {
ExplGroupPieces::Assembled(ir) => return ir,
ExplGroupPieces::Pieces {
open_ir,
body,
close_ir,
spaced,
forced,
} => (open_ir, body, close_ir, spaced, forced),
};
let boundary = if has_comment {
Ir::hard_line()
} else if spaced {
Ir::Line
} else {
Ir::SoftLine
};
Ir::group(Ir::concat([
open_ir,
Ir::indent(Ir::concat([boundary.clone(), body])),
boundary,
close_ir,
]))
}
enum ExplGroupPieces {
Assembled(Ir),
Pieces {
open_ir: Ir,
body: Ir,
close_ir: Ir,
spaced: bool,
forced: bool,
},
}
fn expl_group_pieces(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
) -> ExplGroupPieces {
let mut open_ir = Ir::Nil;
let mut close_ir = Ir::Nil;
let mut body_elements: Vec<SyntaxElement> = Vec::new();
for element in node.children_with_tokens() {
match &element {
SyntaxElement::Token(t) if t.kind() == open && matches!(open_ir, Ir::Nil) => {
open_ir = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == close => {
close_ir = Ir::verbatim(t.text());
}
_ => body_elements.push(element),
}
}
let mut lead_comment = Ir::Nil;
{
let mut i = 0;
let mut spaced = false;
while let Some(SyntaxElement::Token(t)) = body_elements.get(i) {
match t.kind() {
SyntaxKind::WHITESPACE => {
spaced = true;
i += 1;
}
SyntaxKind::COMMENT => {
lead_comment = if spaced {
Ir::concat([Ir::verbatim(" "), Ir::verbatim(t.text())])
} else {
Ir::verbatim(t.text())
};
body_elements.drain(..=i);
break;
}
_ => break,
}
}
}
let has_lead_comment = !matches!(lead_comment, Ir::Nil);
let has_comment = has_lead_comment
|| node
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| {
matches!(
t.kind(),
SyntaxKind::COMMENT | SyntaxKind::GUARD | SyntaxKind::DOC_MARGIN
)
});
let open_ir = Ir::concat([open_ir, lead_comment]);
let body = trim_trailing_break(trim_leading_break(lower_expl_code(
body_elements.into_iter(),
cx,
Statements::Structural,
)));
if matches!(body, Ir::Nil) {
return ExplGroupPieces::Assembled(if has_lead_comment {
Ir::concat([open_ir, Ir::hard_line(), close_ir])
} else {
Ir::concat([open_ir, close_ir])
});
}
ExplGroupPieces::Pieces {
open_ir,
body,
close_ir,
spaced: expl_group_is_spaced(node),
forced: has_comment,
}
}
fn lower_expl_conditional(cmd: &SyntaxNode, cx: LowerCtx<'_>, n: usize) -> Option<Ir> {
let children: Vec<SyntaxElement> = cmd.children_with_tokens().collect();
let group_positions: Vec<usize> = children
.iter()
.enumerate()
.filter(|(_, e)| e.as_node().is_some_and(|nd| nd.kind() == SyntaxKind::GROUP))
.map(|(i, _)| i)
.collect();
if group_positions.len() < n {
return None;
}
let first_branch = group_positions[group_positions.len() - n];
for element in &children[first_branch..] {
match element {
SyntaxElement::Node(nd) if nd.kind() == SyntaxKind::GROUP => {}
SyntaxElement::Token(t)
if is_collapsible_trivia(t.kind()) || t.kind() == SyntaxKind::COMMENT => {}
_ => return None,
}
}
let branch_lines = expl_branch_lines(&children[first_branch..], cx)?;
let head = trim_trailing_break(lower_expl_code(
children[..first_branch].iter().cloned(),
cx,
Statements::Ignore,
));
Some(Ir::concat(std::iter::once(head).chain(branch_lines)))
}
fn expl_branch_lines(tail: &[SyntaxElement], cx: LowerCtx<'_>) -> Option<Vec<Ir>> {
for element in tail {
match element {
SyntaxElement::Node(nd) if nd.kind() == SyntaxKind::GROUP => {}
SyntaxElement::Token(t)
if is_collapsible_trivia(t.kind()) || t.kind() == SyntaxKind::COMMENT => {}
_ => return None,
}
}
let mut parts = Vec::new();
let mut gap = false;
let mut own_line = false;
for element in tail {
match element {
SyntaxElement::Node(nd) => {
let group = lower_expl_group(nd, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx);
parts.push(Ir::indent(Ir::concat([Ir::hard_line(), group])));
(gap, own_line) = (false, false);
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => {
let comment = Ir::verbatim(t.text());
parts.push(if own_line {
Ir::indent(Ir::concat([Ir::hard_line(), comment]))
} else if gap {
Ir::concat([Ir::verbatim(" "), comment])
} else {
comment
});
(gap, own_line) = (false, false);
}
SyntaxElement::Token(t) => {
gap = true;
own_line |= t.kind() == SyntaxKind::NEWLINE;
}
}
}
Some(parts)
}
fn expl_conditional_at(
elements: &[SyntaxElement],
idx: usize,
cx: LowerCtx<'_>,
) -> Option<(Ir, usize)> {
let node = elements.get(idx)?.as_node()?;
if node.kind() != SyntaxKind::COMMAND {
return None;
}
let n = expl3::conditional_branches(&command_name(node)?)?;
let ir = lower_expl_conditional(node, cx, n)?;
Some((ir, idx))
}
fn lower_loose_token(token: &SyntaxToken, cx: LowerCtx<'_>) -> Ir {
if cx.in_dtx_doc_region && token.kind() == SyntaxKind::DOC_MARGIN {
return Ir::Nil;
}
if matches!(token.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD) {
Ir::column_zero(token.text())
} else if cx.absorbs_control_newline(token) {
let before = token
.text()
.strip_suffix('\n')
.expect("absorbed control symbol must end in a newline");
Ir::verbatim(before)
} else {
Ir::verbatim(token.text())
}
}
fn lower_element_stream(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
) -> Vec<Ir> {
let mut out = Vec::new();
let mut iter = elements.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Node(child) => out.push(lower_node(&child, cx)),
SyntaxElement::Token(token)
if cx.in_dtx_doc_region && token.kind() == SyntaxKind::DOC_MARGIN =>
{
while let Some(SyntaxElement::Token(next)) = iter.peek() {
if next.kind() == SyntaxKind::WHITESPACE {
iter.next();
} else {
break;
}
}
}
SyntaxElement::Token(token) if margin_starts_dtx_doc_region(&token, cx) => {
while let Some(SyntaxElement::Token(t)) = iter.peek() {
if t.kind() == SyntaxKind::WHITESPACE {
iter.next();
} else {
break;
}
}
}
SyntaxElement::Token(token)
if is_collapsible_trivia(token.kind()) && cx.suppressed(token.text_range()) =>
{
out.push(Ir::verbatim(token.text().to_string()));
}
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
out.push(classify_trivia(
consume_gap_widened(&token, &mut iter),
cx.in_alignment_cell,
));
}
SyntaxElement::Token(token)
if cx.wraps_prose()
&& !cx.dtx_margin_probe
&& token.kind() == SyntaxKind::DOC_MARGIN
&& margin_floats_into_paragraph(&token, cx) =>
{
while let Some(SyntaxElement::Token(t)) = iter.peek() {
if t.kind() == SyntaxKind::WHITESPACE {
iter.next();
} else {
break;
}
}
}
SyntaxElement::Token(token) => out.push(lower_loose_token(&token, cx)),
}
}
out
}
fn lower_prose_stream(elements: impl Iterator<Item = SyntaxElement>, cx: LowerCtx<'_>) -> Vec<Ir> {
let mut out = Vec::new();
let mut iter = elements.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Node(child) => out.push(lower_node(&child, cx)),
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
out.push(match consume_gap_widened(&token, &mut iter).newlines {
0 => Ir::verbatim(" "),
1 => Ir::hard_line(),
_ => Ir::empty_line(),
});
}
SyntaxElement::Token(token) => out.push(lower_loose_token(&token, cx)),
}
}
out
}
fn lower_environment_leading(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let mut leading: Vec<SyntaxElement> = Vec::new();
for element in node.children_with_tokens() {
if matches!(&element, SyntaxElement::Node(c) if c.kind() == SyntaxKind::BEGIN) {
break;
}
leading.push(element);
}
if leading.is_empty() {
Ir::Nil
} else {
Ir::concat(lower_element_stream(leading.into_iter(), cx))
}
}
struct EnvParts {
leading: Ir,
begin: Ir,
body: Vec<SyntaxElement>,
end: Ir,
lifted: Option<SyntaxToken>,
tail_len: usize,
body_header_token: Option<SyntaxToken>,
}
fn trailing_control_newline(body: &[SyntaxElement]) -> Option<SyntaxToken> {
let first = body.first()?.text_range().start();
let last = body.last()?;
let mut token = match last {
SyntaxElement::Node(node) => node.last_token(),
SyntaxElement::Token(token) => Some(token.clone()),
}?;
loop {
if token.text_range().start() < first {
return None;
}
match token.kind() {
SyntaxKind::WHITESPACE => token = token.prev_token()?,
SyntaxKind::CONTROL_SYMBOL if token.text().ends_with('\n') => return Some(token),
_ => return None,
}
}
}
fn split_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> EnvParts {
let leading = lower_environment_leading(node, cx);
let mut begin = Ir::Nil;
let mut end = Ir::Nil;
let mut body: Vec<SyntaxElement> = Vec::new();
let mut tail_len = 0usize;
let mut seen_begin = false;
for element in node.children_with_tokens() {
match &element {
SyntaxElement::Node(child) if child.kind() == SyntaxKind::BEGIN => {
seen_begin = true;
let parts = lower_begin(child, cx);
begin = parts.header;
tail_len = parts.tail.len();
body.extend(parts.tail);
}
SyntaxElement::Node(child) if child.kind() == SyntaxKind::END => {
end = lower_node(child, cx);
}
_ if !seen_begin => {}
_ => body.push(element),
}
}
let lifted = leading_inline_comment(&body);
if let Some(comment) = &lifted {
begin = Ir::concat([begin, Ir::zero_width(comment.text())]);
}
let body_header_token = picture_header_token(node, &body);
if let Some(token) = &body_header_token {
begin = Ir::concat([begin, lower_loose_token(token, cx)]);
}
EnvParts {
leading,
begin,
body,
end,
lifted,
tail_len,
body_header_token,
}
}
fn picture_header_token(node: &SyntaxNode, body: &[SyntaxElement]) -> Option<SyntaxToken> {
let environment = Environment::cast(node.clone())?;
if environment.name().as_deref() != Some("picture") {
return None;
}
let begin = environment.begin()?;
let paragraph = body.first()?.as_node()?;
if paragraph.kind() != SyntaxKind::PARAGRAPH {
return None;
}
let token = paragraph.first_token()?;
(token.kind() == SyntaxKind::WORD
&& begin.syntax().text_range().end() == token.text_range().start()
&& is_picture_tuple(token.text()))
.then_some(token)
}
fn is_picture_tuple(text: &str) -> bool {
let mut chars = text.chars().peekable();
let mut groups = 0usize;
while chars.peek().is_some() {
if chars.next() != Some('(') {
return false;
}
let mut comma = false;
let mut content = false;
loop {
match chars.next() {
Some(',') if !comma && content => {
comma = true;
content = false;
}
Some(')') if comma && content => break,
Some('(' | ')') | None => return false,
Some(_) => content = true,
}
}
groups += 1;
}
matches!(groups, 1 | 2)
}
fn is_lifted_comment(el: &SyntaxElement, lifted: Option<&SyntaxToken>) -> bool {
lifted.is_some_and(|l| el.as_token() == Some(l))
}
fn paragraph_reflows_as_prose(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.wraps_prose()
&& !is_dtx_doc_paragraph(node)
&& !(cx.any_expl3() && cx.overlaps_expl3(node.text_range()))
}
fn lower_env_body(
body: Vec<SyntaxElement>,
tail_len: usize,
lifted: bool,
body_header_token: Option<&SyntaxToken>,
cx: LowerCtx<'_>,
) -> Ir {
if let Some(header_token) = body_header_token
&& let Some(SyntaxElement::Node(paragraph)) = body.first()
{
let elements = paragraph
.children_with_tokens()
.filter(|element| element.as_token() != Some(header_token));
let first = if cx.wraps_prose() {
reflow_elements(elements, cx, paragraph_reflow_kind(paragraph, cx))
} else {
Ir::concat(lower_element_stream(elements, cx))
};
return Ir::concat(
std::iter::once(first).chain(lower_element_stream(body[1..].iter().cloned(), cx)),
);
}
if tail_len > 0
&& let Some(SyntaxElement::Node(para)) = body.get(tail_len)
&& para.kind() == SyntaxKind::PARAGRAPH
&& paragraph_reflows_as_prose(para, cx)
{
let spliced = reflow_elements(
body[..tail_len]
.iter()
.cloned()
.chain(para.children_with_tokens()),
cx,
paragraph_reflow_kind(para, cx),
);
let rest = lower_element_stream(body[tail_len + 1..].iter().cloned(), cx);
return Ir::concat(std::iter::once(spliced).chain(rest));
}
if tail_len > 0
&& body
.get(tail_len)
.and_then(SyntaxElement::as_node)
.is_some_and(|node| node.kind() == SyntaxKind::MATH)
{
let prefix = lower_math_seq(
body[..tail_len].iter().cloned(),
cx,
MathSpacing::Normal,
false,
);
let rest = lower_element_stream(body[tail_len..].iter().cloned(), cx);
return Ir::concat(std::iter::once(prefix).chain(rest));
}
if lifted {
lower_body_dropping_leading_comment(body, cx)
} else {
Ir::concat(lower_element_stream(body.into_iter(), cx))
}
}
fn lower_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let EnvParts {
leading,
begin,
body,
end,
lifted,
tail_len,
body_header_token,
} = split_environment(node, cx);
let body_cx = cx.absorbing_trailing_control_newline(&body);
let body = lower_env_body(
body,
tail_len,
lifted.is_some(),
body_header_token.as_ref(),
body_cx,
);
let (lead_blank, body) = peel_leading_break(body);
let (trail_blank, body) = peel_trailing_break(body);
let lead = if lead_blank {
Ir::empty_line()
} else {
Ir::hard_line()
};
let trail = if trail_blank {
Ir::empty_line()
} else {
Ir::hard_line()
};
let env = if matches!(body, Ir::Nil) {
Ir::concat([begin, Ir::hard_line(), end])
} else if environment_no_indent(node, cx) {
Ir::concat([begin, lead, body, trail, end])
} else {
Ir::concat([begin, Ir::indent(Ir::concat([lead, body])), trail, end])
};
Ir::concat([leading, env])
}
fn split_branch_gap(node: &SyntaxNode) -> (Vec<SyntaxElement>, Gap) {
let mut elements: Vec<SyntaxElement> = node.children_with_tokens().collect();
let mut peeled = false;
while let Some(SyntaxElement::Token(t)) = elements.last() {
if !is_collapsible_trivia(t.kind()) {
break;
}
peeled = true;
elements.pop();
}
let gap = match elements.last() {
Some(SyntaxElement::Token(t)) if t.kind() == SyntaxKind::COMMENT => Gap::Comment,
_ if peeled => Gap::space(),
_ => Gap::Glued,
};
(elements, gap)
}
fn conditional_interior_reflows(node: &SyntaxNode) -> Option<bool> {
let mut ancestor = node.parent();
while let Some(parent) = ancestor {
match parent.kind() {
SyntaxKind::CONDITIONAL | SyntaxKind::CONDITIONAL_BRANCH => ancestor = parent.parent(),
SyntaxKind::PARAGRAPH => return (!is_dtx_doc_paragraph(&parent)).then_some(true),
_ => return Some(false),
}
}
Some(false)
}
struct ConditionalParts {
leading: Vec<SyntaxElement>,
branches: Vec<SyntaxNode>,
closer: SyntaxNode,
}
fn split_conditional(node: &SyntaxNode) -> Option<ConditionalParts> {
let mut leading: Vec<SyntaxElement> = Vec::new();
let mut branches: Vec<SyntaxNode> = Vec::new();
let mut closer: Option<SyntaxNode> = None;
for element in node.children_with_tokens() {
match &element {
SyntaxElement::Node(child) if child.kind() == SyntaxKind::CONDITIONAL_BRANCH => {
if closer.is_some() {
return None;
}
branches.push(child.clone());
}
SyntaxElement::Node(child)
if child.kind() == SyntaxKind::COMMAND && !branches.is_empty() =>
{
if closer.replace(child.clone()).is_some() {
return None;
}
}
_ if branches.is_empty() => leading.push(element),
_ => return None,
}
}
Some(ConditionalParts {
leading,
branches,
closer: closer?,
})
}
fn lower_conditional(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let generic = || Ir::concat(lower_element_stream(node.children_with_tokens(), cx));
if !cx.wraps_prose() {
return generic();
}
let Some(reflow_interior) = conditional_interior_reflows(node) else {
return generic();
};
let Some(ConditionalParts {
leading,
branches,
closer,
}) = split_conditional(node)
else {
return generic();
};
let split: Vec<(Vec<SyntaxElement>, Gap)> = branches.iter().map(split_branch_gap).collect();
if split.iter().any(|(_, gap)| matches!(gap, Gap::Glued)) {
return generic();
}
let leading = if leading.is_empty() {
Ir::Nil
} else {
Ir::concat(lower_element_stream(leading.into_iter(), cx))
};
let closer_ir = lower_node(&closer, cx);
let mut broken = Vec::with_capacity(split.len() * 2 + 1);
for (elements, _) in &split {
broken.push(if reflow_interior {
reflow_elements(elements.iter().cloned(), cx, ReflowKind::Prose)
} else {
Ir::concat(lower_element_stream(elements.iter().cloned(), cx))
});
broken.push(Ir::hard_line());
}
broken.push(closer_ir.clone());
let broken = Ir::concat(broken);
let group = match collapse_conditional(&split, &closer_ir, cx) {
Some(flat) => Ir::conditional_group_all_lines([flat, broken]),
None => broken,
};
Ir::concat([leading, group])
}
fn collapse_conditional(
split: &[(Vec<SyntaxElement>, Gap)],
closer: &Ir,
cx: LowerCtx<'_>,
) -> Option<Ir> {
if closer.contains_forced_break() {
return None;
}
let mut parts = Vec::new();
for (elements, _) in split {
parts.extend(collapse_conditional_elements(elements, cx)?);
parts.push(Ir::verbatim(" "));
}
parts.push(closer.clone());
Some(Ir::concat(parts))
}
fn collapse_conditional_elements(elements: &[SyntaxElement], cx: LowerCtx<'_>) -> Option<Vec<Ir>> {
let mut out = Vec::new();
let mut iter = elements.iter().cloned().peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
let gap = consume_gap(&t, &mut iter);
if gap == Gap::Blank {
return None; }
out.push(Ir::verbatim(gap.flat()));
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => return None,
SyntaxElement::Token(t) => out.push(Ir::verbatim(t.text())),
SyntaxElement::Node(child) => {
let ir = lower_node(&child, cx);
if ir.contains_forced_break() {
return None; }
out.push(ir);
}
}
}
Some(out)
}
fn is_margin_framed(node: &SyntaxNode) -> bool {
let Some(begin) = Environment::cast(node.clone()).and_then(|e| e.begin()) else {
return false;
};
if begin
.syntax()
.last_token()
.and_then(|token| token.next_token())
.is_some_and(|token| token.kind() != SyntaxKind::NEWLINE)
{
return false;
}
let mut tok = begin.syntax().first_token().and_then(|t| t.prev_token());
while let Some(t) = tok {
match t.kind() {
SyntaxKind::WHITESPACE => tok = t.prev_token(),
SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD => return true,
_ => return false,
}
}
false
}
fn split_closing_frame(body: &mut Vec<SyntaxElement>) -> Option<Vec<SyntaxElement>> {
let mut boundary = body.len();
let mut has_margin = false;
while boundary > 0 {
match &body[boundary - 1] {
SyntaxElement::Token(t)
if matches!(t.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD) =>
{
has_margin = true;
boundary -= 1;
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::WHITESPACE => boundary -= 1,
_ => break,
}
}
has_margin.then(|| body.split_off(boundary))
}
fn lower_margin_framed_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let EnvParts {
leading,
begin,
mut body,
end,
lifted,
tail_len,
body_header_token: _,
} = split_environment(node, cx);
let frame = split_closing_frame(&mut body);
let frame_ir = frame
.map(|f| Ir::concat(lower_element_stream(f.into_iter(), cx)))
.filter(|ir| !matches!(ir, Ir::Nil));
let body_cx = cx.absorbing_trailing_control_newline(&body);
let body = lower_env_body(body, tail_len, lifted.is_some(), None, body_cx);
let (lead_blank, body) = peel_leading_break(body);
let (trail_blank, body) = peel_trailing_break(body);
let lead = if lead_blank {
Ir::empty_line()
} else {
Ir::hard_line()
};
let close_break = if trail_blank {
Ir::empty_line()
} else {
Ir::hard_line()
};
let env = match (matches!(body, Ir::Nil), frame_ir) {
(true, Some(frame_ir)) => Ir::concat([begin, close_break, frame_ir, end]),
(true, None) => Ir::concat([begin, Ir::hard_line(), end]),
(false, Some(frame_ir)) => Ir::concat([begin, lead, body, close_break, frame_ir, end]),
(false, None) => Ir::concat([begin, lead, body, close_break, end]),
};
Ir::concat([leading, env])
}
fn leading_inline_comment(body_elements: &[SyntaxElement]) -> Option<SyntaxToken> {
for element in body_elements {
match element {
SyntaxElement::Token(token) => match token.kind() {
SyntaxKind::WHITESPACE => continue,
SyntaxKind::COMMENT => return Some(token.clone()),
_ => return None,
},
SyntaxElement::Node(node) => {
for token in node
.descendants_with_tokens()
.filter_map(|e| e.into_token())
{
match token.kind() {
SyntaxKind::WHITESPACE => continue,
SyntaxKind::COMMENT => return Some(token),
_ => return None,
}
}
}
}
}
None
}
fn lower_body_dropping_leading_comment(body_elements: Vec<SyntaxElement>, cx: LowerCtx<'_>) -> Ir {
let mut out: Vec<Ir> = Vec::new();
let mut iter = body_elements.into_iter();
for element in iter.by_ref() {
match element {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::WHITESPACE => continue,
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => break,
SyntaxElement::Node(node) => {
out.push(lower_node_dropping_leading_comment(&node, cx));
break;
}
SyntaxElement::Token(token) => {
out.push(lower_loose_token(&token, cx));
break;
}
}
}
out.extend(lower_element_stream(iter, cx));
Ir::concat(out)
}
fn lower_node_dropping_leading_comment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let mut children: Vec<SyntaxElement> = node.children_with_tokens().collect();
let mut i = 0;
while matches!(
children.get(i).and_then(|c| c.as_token()).map(|t| t.kind()),
Some(SyntaxKind::WHITESPACE)
) {
i += 1;
}
if matches!(
children.get(i).and_then(|c| c.as_token()).map(|t| t.kind()),
Some(SyntaxKind::COMMENT)
) {
children.drain(..=i);
}
if node.kind() == SyntaxKind::PARAGRAPH && cx.wraps_prose() {
reflow_elements(children.into_iter(), cx, ReflowKind::Prose)
} else {
Ir::concat(lower_element_stream(children.into_iter(), cx))
}
}
fn environment_no_indent(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.environment_at(node)
.is_some_and(|sig| sig.no_indent)
}
fn in_statement_body_env(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
node.ancestors()
.skip(1)
.find(|ancestor| ancestor.kind() == SyntaxKind::ENVIRONMENT)
.and_then(|env| cx.signatures.environment_at(&env))
.is_some_and(|sig| sig.statement_body)
}
fn in_algorithm2e_env(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
let Some(env) = node
.ancestors()
.skip(1)
.find(|ancestor| ancestor.kind() == SyntaxKind::ENVIRONMENT)
.filter(|env| {
cx.signatures
.environment_at(env)
.is_some_and(|sig| sig.algorithm2e)
})
else {
return false;
};
if let Some(&proved) = cx.algorithm2e_cache.borrow().get(&env) {
return proved;
}
let proved = env
.children()
.filter(|child| child.kind() == SyntaxKind::PARAGRAPH)
.flat_map(|paragraph| paragraph.children())
.any(|command| {
cx.signatures.command_at(&command).is_some_and(|sig| {
sig.args
.iter()
.any(|arg| arg.content == ContentKind::Algorithm2e)
})
});
cx.algorithm2e_cache.borrow_mut().insert(env, proved);
proved
}
struct BeginParts {
header: Ir,
tail: Vec<SyntaxElement>,
}
fn lower_begin(begin: &SyntaxNode, cx: LowerCtx<'_>) -> BeginParts {
let sig = cx.signatures.environment_at(begin);
let mut has_comment = false;
let mut has_margin = false;
for token in begin
.children_with_tokens()
.filter_map(|element| element.into_token())
{
match token.kind() {
SyntaxKind::COMMENT => has_comment = true,
SyntaxKind::DOC_MARGIN if !cx.in_dtx_doc_region => has_margin = true,
SyntaxKind::GUARD => has_margin = true,
_ => {}
}
}
if has_margin {
return BeginParts {
header: lower_node(begin, cx),
tail: Vec::new(),
};
}
let args = sig.as_ref().map(|sig| &*sig.args).unwrap_or(&[]);
if has_comment && !args.is_empty() {
return lower_commented_begin(begin, cx, args);
}
let elements: Vec<SyntaxElement> = begin.children_with_tokens().collect();
let mut head: Vec<Ir> = Vec::new();
let mut slot = 0usize;
let mut signature_matches = true;
let mut i = 0usize;
while let Some(element) = elements.get(i) {
match element {
SyntaxElement::Token(token)
if cx.in_dtx_doc_region && token.kind() == SyntaxKind::DOC_MARGIN =>
{
i += 1;
while matches!(
elements.get(i),
Some(SyntaxElement::Token(next)) if next.kind() == SyntaxKind::WHITESPACE
) {
i += 1;
}
}
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
let (mut end, mut newlines, mut flat) = (i, 0usize, String::new());
while let Some(SyntaxElement::Token(token)) = elements.get(end) {
if !is_collapsible_trivia(token.kind()) {
break;
}
newlines += usize::from(token.kind() == SyntaxKind::NEWLINE);
flat.push_str(token.text());
end += 1;
}
let mut next_slot = slot;
let declared_arg_follows = signature_matches
&& elements
.get(end)
.and_then(attached_arg_kind)
.and_then(|kind| match_arg_slot(args, &mut next_slot, kind))
.is_some();
if declared_arg_follows {
i = end;
continue;
}
let trails_comment = newlines == 0
&& matches!(
elements.get(end),
Some(SyntaxElement::Token(token)) if token.kind() == SyntaxKind::COMMENT
);
if trails_comment {
head.push(Ir::verbatim(flat));
i = end;
continue;
}
return BeginParts {
header: Ir::concat(head),
tail: elements[i..].to_vec(),
};
}
SyntaxElement::Node(child)
if matches!(child.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL) =>
{
let kind = attached_arg_kind(element).expect("group or optional argument");
let spec = signature_matches
.then(|| match_arg_slot(args, &mut slot, kind))
.flatten();
if spec.is_none() && slot < args.len() {
signature_matches = false;
}
let keyval = spec.is_some_and(|spec| spec.content == ContentKind::Keyval);
let colspec = !keyval
&& child.kind() == SyntaxKind::GROUP
&& spec.is_some()
&& slot == args.len()
&& sig.as_ref().is_some_and(|sig| sig.align);
let segmented = if keyval {
Some(match child.kind() {
SyntaxKind::OPTIONAL => lower_optional(child, cx, true),
SyntaxKind::GROUP => lower_segmented_group(
child,
SyntaxKind::L_BRACE,
SyntaxKind::R_BRACE,
cx,
true,
),
_ => unreachable!("argument kind checked above"),
})
} else if colspec {
Some(lower_column_spec_group(child, cx))
} else {
None
};
let argument = segmented.flatten().unwrap_or_else(|| {
lower_header_argument(child, spec.map(|spec| spec.content), cx)
});
head.push(if spec.is_some() {
Ir::indent(argument)
} else {
argument
});
i += 1;
}
SyntaxElement::Node(child) => {
head.push(lower_node(child, cx));
i += 1;
}
SyntaxElement::Token(token) => {
head.push(lower_loose_token(token, cx));
i += 1;
}
}
}
BeginParts {
header: Ir::concat(head),
tail: Vec::new(),
}
}
fn attached_arg_kind(element: &SyntaxElement) -> Option<ArgKind> {
match element.as_node()?.kind() {
SyntaxKind::GROUP => Some(ArgKind::Brace),
SyntaxKind::OPTIONAL => Some(ArgKind::Bracket),
_ => None,
}
}
fn lower_header_argument(node: &SyntaxNode, content: Option<ContentKind>, cx: LowerCtx<'_>) -> Ir {
if content == Some(ContentKind::Opaque)
&& node.kind() == SyntaxKind::GROUP
&& matches!(cx.wrap, WrapMode::Reflow)
&& !cx.suppressed(node.text_range())
&& !cx.preserve_dtx_nested_layout
&& !contains_doc_margin(node, cx)
&& !doc_margin_opens_line(node, cx)
&& let Some(argument) =
collapse_arg_group(node, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx)
{
return argument;
}
lower_node(node, cx)
}
fn lower_commented_header_stream(
elements: &[SyntaxElement],
declared: &[Option<ContentKind>],
mut previous_was_comment: bool,
cx: LowerCtx<'_>,
) -> Ir {
if cx.in_dtx_doc_region {
return Ir::concat(lower_element_stream(elements.iter().cloned(), cx));
}
let mut filtered = Vec::with_capacity(elements.len());
let mut i = 0usize;
while i < elements.len() {
let SyntaxElement::Token(token) = &elements[i] else {
previous_was_comment = false;
filtered.push((elements[i].clone(), declared[i]));
i += 1;
continue;
};
if !is_collapsible_trivia(token.kind()) {
previous_was_comment = token.kind() == SyntaxKind::COMMENT;
filtered.push((elements[i].clone(), declared[i]));
i += 1;
continue;
}
let start = i;
while matches!(
elements.get(i),
Some(SyntaxElement::Token(token)) if is_collapsible_trivia(token.kind())
) {
i += 1;
}
let followed_by_declared = declared.get(i).is_some_and(Option::is_some);
let suppressed = elements[start..i].iter().any(|element| {
element
.as_token()
.is_some_and(|token| cx.suppressed(token.text_range()))
});
if followed_by_declared && !previous_was_comment && !suppressed {
continue;
}
filtered.extend(
elements[start..i]
.iter()
.cloned()
.zip(declared[start..i].iter().copied()),
);
}
let mut lowered = Vec::new();
let mut generic = Vec::new();
for (element, content) in filtered {
if content.is_none() {
generic.push(element);
continue;
}
lowered.extend(lower_element_stream(generic.drain(..), cx));
let node = element
.into_node()
.expect("declared environment argument must be a syntax node");
lowered.push(Ir::indent(lower_header_argument(&node, content, cx)));
}
lowered.extend(lower_element_stream(generic.into_iter(), cx));
Ir::concat(lowered)
}
fn lower_commented_begin(begin: &SyntaxNode, cx: LowerCtx<'_>, args: &[ArgSpec]) -> BeginParts {
let elements: Vec<SyntaxElement> = begin.children_with_tokens().collect();
let mut declared = vec![None; elements.len()];
let mut required_brace = vec![false; elements.len()];
let mut slot = 0usize;
let mut signature_matches = true;
for (i, element) in elements.iter().enumerate() {
let Some(kind) = attached_arg_kind(element) else {
continue;
};
let spec = signature_matches
.then(|| match_arg_slot(args, &mut slot, kind))
.flatten();
if spec.is_none() && slot < args.len() {
signature_matches = false;
}
if let Some(spec) = spec {
declared[i] = Some(spec.content);
required_brace[i] = spec.required && kind == ArgKind::Brace;
}
}
let split = elements
.iter()
.enumerate()
.find_map(|(i, element)| {
let SyntaxElement::Token(token) = element else {
return None;
};
if !is_collapsible_trivia(token.kind()) {
return None;
}
let mut end = i;
let mut newlines = 0usize;
while let Some(SyntaxElement::Token(token)) = elements.get(end) {
if !is_collapsible_trivia(token.kind()) {
break;
}
newlines += usize::from(token.kind() == SyntaxKind::NEWLINE);
end += 1;
}
if declared.get(end).is_some_and(Option::is_some)
|| (newlines == 0
&& matches!(
elements.get(end),
Some(SyntaxElement::Token(token)) if token.kind() == SyntaxKind::COMMENT
))
{
None
} else {
Some(i)
}
})
.unwrap_or(elements.len());
let header_elements = &elements[..split];
let header = header_elements
.iter()
.enumerate()
.find_map(|(i, element)| {
let SyntaxElement::Token(comment) = element else {
return None;
};
if comment.kind() != SyntaxKind::COMMENT {
return None;
}
let trails_argument =
header_elements[..i]
.iter()
.enumerate()
.rev()
.find_map(|(index, previous)| match previous {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::WHITESPACE => {
None
}
SyntaxElement::Node(_) => Some(declared[index].is_some()),
_ => Some(false),
})
== Some(true);
if !trails_argument {
return None;
}
let mut next = i + 1;
let mut has_newline = false;
while let Some(SyntaxElement::Token(token)) = header_elements.get(next) {
if !is_collapsible_trivia(token.kind()) {
break;
}
has_newline |= token.kind() == SyntaxKind::NEWLINE;
next += 1;
}
if !has_newline
|| !declared.get(next).is_some_and(Option::is_some)
|| !required_brace[next..split].contains(&true)
{
return None;
}
let prefix =
lower_commented_header_stream(&header_elements[..=i], &declared[..=i], false, cx);
let continuation = lower_commented_header_stream(
&header_elements[i + 1..],
&declared[i + 1..split],
true,
cx,
);
Some(Ir::concat([prefix, Ir::indent(continuation)]))
})
.unwrap_or_else(|| {
lower_commented_header_stream(header_elements, &declared[..split], false, cx)
});
BeginParts {
header,
tail: elements[split..].to_vec(),
}
}
fn is_list_env(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.environment_at(node)
.is_some_and(|sig| sig.list)
}
struct ListItem {
doc_lines: Vec<String>,
marker: String,
hang: usize,
glue_body: bool,
chunks: Vec<Vec<SyntaxElement>>,
blank_before: bool,
}
enum FlatItem {
El(SyntaxElement),
Blank,
}
fn lower_list_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let EnvParts {
leading,
begin,
body,
end,
lifted,
tail_len: _,
body_header_token: _,
} = split_environment(node, cx);
let body_cx = cx.absorbing_trailing_control_newline(&body);
let Some(body) = lower_list_body(&body, body_cx, lifted.as_ref()) else {
return lower_environment(node, cx);
};
Ir::concat([
leading,
begin,
Ir::indent(Ir::concat([Ir::hard_line(), body])),
Ir::hard_line(),
end,
])
}
fn lower_list_body(
body_elements: &[SyntaxElement],
cx: LowerCtx<'_>,
lifted: Option<&SyntaxToken>,
) -> Option<Ir> {
let flat = flatten_list_body(body_elements, lifted);
let mut preamble: Vec<Vec<SyntaxElement>> = vec![Vec::new()];
let mut items: Vec<ListItem> = Vec::new();
let mut blank_pending = false;
let mut index = 0;
while index < flat.len() {
match &flat[index] {
FlatItem::Blank => {
blank_pending = true;
match items.last_mut() {
Some(item) => item.chunks.push(Vec::new()),
None => preamble.push(Vec::new()),
}
index += 1;
}
FlatItem::El(el) if is_item_command(el) => {
let mut item = split_item_marker(el, cx);
index += 1;
if let Some((suffix, end)) = item_overlay_marker_suffix(&flat, index) {
item.marker.push_str(&suffix);
item.glue_body = flat.get(end).is_some_and(
|next| matches!(next, FlatItem::El(el) if el.kind() == SyntaxKind::COMMENT),
);
index = end;
}
item.blank_before = blank_pending;
items.push(item);
blank_pending = false;
}
FlatItem::El(el) => {
match items.last_mut() {
Some(item) => item.chunks.last_mut().unwrap().push(el.clone()),
None => preamble.last_mut().unwrap().push(el.clone()),
}
blank_pending = false;
index += 1;
}
}
}
if items.is_empty() {
return None;
}
let mut segments: Vec<Ir> = Vec::new();
let mut seps: Vec<Ir> = Vec::new();
let preamble_ir = lower_item_chunks(&preamble, cx);
if !matches!(preamble_ir, Ir::Nil) {
seps.push(Ir::hard_line()); segments.push(preamble_ir);
}
for item in &items {
seps.push(if item.blank_before {
Ir::empty_line()
} else {
Ir::hard_line()
});
segments.push(render_list_item(item, cx));
}
let mut result: Vec<Ir> = Vec::with_capacity(segments.len().saturating_mul(2));
for (i, segment) in segments.into_iter().enumerate() {
if i > 0 {
result.push(seps[i].clone());
}
result.push(segment);
}
Some(Ir::concat(result))
}
fn render_list_item(item: &ListItem, cx: LowerCtx<'_>) -> Ir {
let content = lower_item_chunks(&item.chunks, cx);
let marker = Ir::verbatim(item.marker.clone());
let body = if matches!(content, Ir::Nil) {
marker
} else {
let separator = if item.glue_body {
Ir::Nil
} else {
Ir::verbatim(" ")
};
let continuation_indent = match cx.item_indent {
ItemIndent::Hang => item.hang,
ItemIndent::Indent => cx.indent_width,
ItemIndent::None => 0,
};
Ir::concat([marker, separator, Ir::align(continuation_indent, content)])
};
if item.doc_lines.is_empty() {
return body;
}
let doc = item.doc_lines.iter().map(|line| Ir::verbatim(line.clone()));
Ir::concat([Ir::join(Ir::hard_line(), doc), Ir::hard_line(), body])
}
fn lower_item_chunks(chunks: &[Vec<SyntaxElement>], cx: LowerCtx<'_>) -> Ir {
if cx.wraps_prose() {
reflow_chunks(chunks, cx)
} else {
preserve_chunks(chunks, cx)
}
}
fn preserve_chunks(chunks: &[Vec<SyntaxElement>], cx: LowerCtx<'_>) -> Ir {
let parts = chunks
.iter()
.map(|chunk| {
let flat = flatten_inline_prose(chunk.clone(), cx, false);
let ir = Ir::concat(lower_prose_stream(flat.into_iter(), cx));
let (_, ir) = peel_leading_break(ir);
let (_, ir) = peel_trailing_break(ir);
ir
})
.filter(|ir| !matches!(ir, Ir::Nil));
Ir::join(Ir::empty_line(), parts)
}
fn reflow_chunks(chunks: &[Vec<SyntaxElement>], cx: LowerCtx<'_>) -> Ir {
let parts = chunks
.iter()
.map(|chunk| reflow_elements(chunk.iter().cloned(), cx, ReflowKind::Prose))
.filter(|ir| !matches!(ir, Ir::Nil));
Ir::join(Ir::empty_line(), parts)
}
fn flatten_list_body(
body_elements: &[SyntaxElement],
lifted: Option<&SyntaxToken>,
) -> Vec<FlatItem> {
let mut out: Vec<FlatItem> = Vec::new();
let mut started = false;
let mut run: Vec<SyntaxElement> = Vec::new();
let mut run_newlines = 0usize;
for element in body_elements {
match element {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
if t.kind() == SyntaxKind::NEWLINE {
run_newlines += 1;
}
run.push(element.clone());
continue;
}
other if is_lifted_comment(other, lifted) => continue,
_ => {}
}
if started {
if run_newlines >= 2 {
out.push(FlatItem::Blank);
} else {
out.extend(run.drain(..).map(FlatItem::El));
}
}
run.clear();
run_newlines = 0;
match element {
SyntaxElement::Node(p) if p.kind() == SyntaxKind::PARAGRAPH => {
out.extend(
p.children_with_tokens()
.filter(|e| !is_lifted_comment(e, lifted))
.map(FlatItem::El),
);
}
other => out.push(FlatItem::El(other.clone())),
}
started = true;
}
out
}
fn is_item_command(el: &SyntaxElement) -> bool {
el.as_node().is_some_and(|node| {
node.kind() == SyntaxKind::COMMAND && command_name(node).as_deref() == Some("item")
})
}
fn item_overlay_marker_suffix(flat: &[FlatItem], start: usize) -> Option<(String, usize)> {
let (mut suffix, mut end) = angle_suffix(flat, start)?;
if let Some((label, label_end)) = bracket_suffix(flat, end) {
suffix.push_str(&label);
end = label_end;
if let Some((overlay, overlay_end)) = angle_suffix(flat, end) {
suffix.push_str(&overlay);
end = overlay_end;
}
}
Some((suffix, end))
}
fn angle_suffix(flat: &[FlatItem], start: usize) -> Option<(String, usize)> {
let mut index = skip_flat_trivia(flat, start);
let first = flat_element(flat.get(index)?)?;
let first_text = element_source_text(first);
if !first_text.starts_with('<') {
return None;
}
let mut suffix = String::new();
loop {
let element = flat_element(flat.get(index)?)?;
if element.kind() == SyntaxKind::COMMENT {
return None;
}
if is_collapsible_trivia(element.kind()) {
if !suffix.ends_with(' ') {
suffix.push(' ');
}
} else {
let text = element_source_text(element);
suffix.push_str(&text);
if text.ends_with('>') {
return Some((suffix, index + 1));
}
}
index += 1;
}
}
fn bracket_suffix(flat: &[FlatItem], start: usize) -> Option<(String, usize)> {
let mut index = skip_flat_trivia(flat, start);
let first = flat_element(flat.get(index)?)?;
if first.kind() != SyntaxKind::L_BRACKET {
return None;
}
let mut depth = 0usize;
let mut suffix = String::new();
loop {
let element = flat_element(flat.get(index)?)?;
match element.kind() {
SyntaxKind::L_BRACKET => depth += 1,
SyntaxKind::R_BRACKET => depth = depth.checked_sub(1)?,
SyntaxKind::COMMENT => return None,
_ => {}
}
if is_collapsible_trivia(element.kind()) {
if !suffix.ends_with(' ') {
suffix.push(' ');
}
} else {
suffix.push_str(&element_source_text(element));
}
index += 1;
if depth == 0 {
return Some((suffix, index));
}
}
}
fn skip_flat_trivia(flat: &[FlatItem], mut index: usize) -> usize {
while let Some(FlatItem::El(element)) = flat.get(index) {
if !is_collapsible_trivia(element.kind()) {
break;
}
index += 1;
}
index
}
fn flat_element(item: &FlatItem) -> Option<&SyntaxElement> {
match item {
FlatItem::El(element) => Some(element),
FlatItem::Blank => None,
}
}
fn element_source_text(element: &SyntaxElement) -> String {
match element {
SyntaxElement::Node(node) => node.text().to_string(),
SyntaxElement::Token(token) => token.text().to_string(),
}
}
fn split_item_marker(el: &SyntaxElement, cx: LowerCtx<'_>) -> ListItem {
let node = el.as_node().expect("item command is a node");
let mut doc_lines: Vec<String> = Vec::new();
let mut marker_parts: Vec<Ir> = Vec::new();
let mut content: Vec<SyntaxElement> = Vec::new();
let mut hang = 1; let mut in_content = false;
for child in node.children_with_tokens() {
if in_content {
content.push(child);
continue;
}
match &child {
SyntaxElement::Node(n) if n.kind() == SyntaxKind::DOC_COMMENT => {
doc_lines.extend(
n.children_with_tokens()
.filter_map(|e| e.into_token())
.filter(|t| t.kind() == SyntaxKind::COMMENT)
.map(|t| t.text().to_string()),
);
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::CONTROL_WORD => {
hang += t.text().chars().count();
marker_parts.push(Ir::verbatim(t.text()));
}
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {}
SyntaxElement::Node(n) if n.kind() == SyntaxKind::OPTIONAL => {
marker_parts.push(lower_node(n, cx));
}
other => {
in_content = true;
content.push(other.clone());
}
}
}
let marker = Printer::new(FormatStyle::default()).print_flat(&Ir::concat(marker_parts));
ListItem {
doc_lines,
marker,
hang,
glue_body: false,
chunks: vec![content],
blank_before: false,
}
}
fn is_alignment_env(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.environment_at(node)
.is_some_and(|sig| sig.align)
}
fn body_has_top_level_ampersand(node: &SyntaxNode) -> bool {
node.children_with_tokens().any(|el| match el {
SyntaxElement::Token(t) => t.kind() == SyntaxKind::AMPERSAND,
SyntaxElement::Node(p) if p.kind() == SyntaxKind::PARAGRAPH => p
.children_with_tokens()
.any(|g| g.kind() == SyntaxKind::AMPERSAND),
_ => false,
})
}
fn is_math_env(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.environment_at(node)
.is_some_and(|sig| sig.math)
}
struct Cell {
text: String,
span: usize,
caption: bool,
align: Option<ColAlign>,
block: Option<BlockCell>,
}
struct BlockCell {
hang: usize,
ir: Ir,
}
struct AlignRow {
cells: Vec<Cell>,
line_break: Option<String>,
trailing_comment: Option<String>,
}
enum GridItem {
Row(AlignRow),
Passthrough(String),
Intertext(Ir),
}
fn lower_aligned_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let EnvParts {
leading,
begin,
body,
end,
lifted,
tail_len: _,
body_header_token: _,
} = split_environment(node, cx);
let body_cx = cx.absorbing_trailing_control_newline(&body);
let soften_nested_newlines = cx.in_dtx_doc_region && !is_math_env(node, cx);
let Some(items) = build_alignment_grid(
&body,
body_cx,
false,
soften_nested_newlines,
lifted.as_ref(),
) else {
return lower_environment(node, cx);
};
if !items.iter().any(|item| matches!(item, GridItem::Row(_))) {
return lower_environment(node, cx);
}
let aligns = column_alignments(node, cx).unwrap_or_default();
let body = render_alignment_rows(&items, &aligns);
Ir::concat([
leading,
begin,
Ir::indent(Ir::concat([Ir::hard_line(), body])),
Ir::hard_line(),
end,
])
}
fn lower_math_environment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let EnvParts {
leading,
begin,
body: body_elements,
end,
lifted,
tail_len: _,
body_header_token: _,
} = split_environment(node, cx);
let body_cx = cx.absorbing_trailing_control_newline(&body_elements);
let Some(math_node) = body_elements
.iter()
.filter_map(|e| e.as_node())
.find(|n| n.kind() == SyntaxKind::MATH)
else {
return lower_environment(node, cx);
};
let is_grid = math_node.children_with_tokens().any(|e| {
matches!(e.kind(), SyntaxKind::AMPERSAND | SyntaxKind::LINE_BREAK)
|| grid_intertext(&e, body_cx).is_some()
});
let body = if let Some(body) =
lower_tikzcd_arrow_body(node, &body_elements, lifted.as_ref(), body_cx)
{
body
} else if is_grid {
match build_alignment_grid(&body_elements, body_cx, true, false, lifted.as_ref()) {
Some(items) if items.iter().any(|item| matches!(item, GridItem::Row(_))) => {
let aligns = column_alignments(node, cx).unwrap_or_default();
render_alignment_rows(&items, &aligns)
}
_ => return lower_environment(node, cx),
}
} else {
let mut elements: Vec<SyntaxElement> = Vec::new();
for element in &body_elements {
if element.as_node() == Some(math_node) {
elements.extend(math_node.children_with_tokens());
} else {
elements.push(element.clone());
}
}
elements.retain(|e| !is_lifted_comment(e, lifted.as_ref()));
if elements.iter().all(|e| {
e.as_token()
.is_some_and(|t| is_collapsible_trivia(t.kind()))
}) {
return Ir::concat([leading, begin, Ir::hard_line(), end]);
}
trim_trailing_break(lower_display_formula_elements(&elements, body_cx))
};
Ir::concat([
leading,
begin,
Ir::indent(Ir::concat([Ir::hard_line(), body])),
Ir::hard_line(),
end,
])
}
fn lower_tikzcd_arrow_body(
node: &SyntaxNode,
body: &[SyntaxElement],
lifted: Option<&SyntaxToken>,
cx: LowerCtx<'_>,
) -> Option<Ir> {
if Environment::cast(node.clone())?.name().as_deref() != Some("tikzcd") {
return None;
}
let mut inline = flatten_alignment_body(body, cx, true)?;
inline.retain(|element| !is_lifted_comment(element, lifted));
let mut start = None;
for (idx, element) in inline.iter().enumerate().rev() {
if is_collapsible_trivia_element(element) || element.kind() == SyntaxKind::COMMENT {
continue;
}
let Some(command) = element
.as_node()
.and_then(|node| Command::cast(node.clone()))
else {
break;
};
if !matches!(command.name().as_deref(), Some("arrow" | "ar"))
|| cx.suppressed(command.syntax().text_range())
|| command.groups().next().is_some()
{
break;
}
let mut optionals = command.optionals();
let Some(optional) = optionals.next() else {
break;
};
if optionals.next().is_some() || !tikzcd_arrow_has_endpoints(optional.syntax()) {
break;
}
start = Some(idx);
}
let start = start?;
let items = build_alignment_grid_inline(inline[..start].to_vec(), cx, true, false)?;
let aligns = column_alignments(node, cx).unwrap_or_default();
let mut parts = Vec::new();
if !items.is_empty() {
parts.extend([render_alignment_rows(&items, &aligns), Ir::hard_line()]);
}
let mut own_line = false;
for element in &inline[start..] {
match element {
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
own_line |= token.kind() == SyntaxKind::NEWLINE;
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => {
parts.push(if own_line {
Ir::hard_line()
} else {
Ir::text(" ")
});
parts.push(Ir::verbatim(token.text().trim_end()));
own_line = false;
}
SyntaxElement::Node(command) => {
if element != &inline[start] {
parts.push(Ir::hard_line());
}
for child in command.children_with_tokens() {
if let Some(comment) = child
.as_node()
.filter(|n| n.kind() == SyntaxKind::DOC_COMMENT)
{
parts.push(Ir::join(
Ir::hard_line(),
comment
.children_with_tokens()
.filter_map(SyntaxElement::into_token)
.filter(|token| token.kind() == SyntaxKind::COMMENT)
.map(|token| Ir::verbatim(token.text().trim_end())),
));
parts.push(Ir::hard_line());
} else {
parts.push(Ir::verbatim(child.to_string()));
}
}
own_line = false;
}
_ => unreachable!("the suffix contains only arrows, comments, and trivia"),
}
}
Some(Ir::concat(parts))
}
fn tikzcd_arrow_has_endpoints(optional: &SyntaxNode) -> bool {
let children: Vec<_> = optional.children_with_tokens().collect();
let mut entry = String::new();
let mut quoted = false;
let mut from = false;
let mut to = false;
let mut finish_entry = |entry: &str| {
if let Some((key, value)) = entry.split_once('=') {
match key.trim() {
"from" => from = !value.trim().is_empty(),
"to" => to = !value.trim().is_empty(),
_ => {}
}
}
};
for child in &children[1..children.len() - 1] {
match child {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::WORD => {
for ch in token.text().chars() {
if ch == '"' {
quoted = !quoted;
}
if ch == ',' && !quoted {
finish_entry(&entry);
entry.clear();
} else {
entry.push(ch);
}
}
}
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => entry.push(' '),
SyntaxElement::Token(token)
if matches!(
token.kind(),
SyntaxKind::COMMENT | SyntaxKind::L_BRACKET | SyntaxKind::R_BRACKET
) =>
{
return false;
}
_ => entry.push('\0'),
}
}
finish_entry(&entry);
!quoted && from && to
}
fn build_alignment_grid(
body_elements: &[SyntaxElement],
cx: LowerCtx<'_>,
math: bool,
soften_nested_newlines: bool,
lifted: Option<&SyntaxToken>,
) -> Option<Vec<GridItem>> {
let mut inline = flatten_alignment_body(body_elements, cx, math)?;
inline.retain(|e| !is_lifted_comment(e, lifted));
build_alignment_grid_inline(inline, cx, math, soften_nested_newlines)
}
fn build_alignment_grid_inline(
mut inline: Vec<SyntaxElement>,
cx: LowerCtx<'_>,
math: bool,
soften_nested_newlines: bool,
) -> Option<Vec<GridItem>> {
let printer = Printer::new(FormatStyle::default());
let cell_cx = LowerCtx {
in_alignment_cell: soften_nested_newlines,
..cx
};
fn finish_cell(
cell: &mut Vec<SyntaxElement>,
cells: &mut Vec<Cell>,
printer: &Printer,
cx: LowerCtx<'_>,
math: bool,
) -> Option<()> {
let is_edge_trivia = |e: &SyntaxElement| {
e.as_token()
.is_some_and(|t| is_collapsible_trivia(t.kind()))
};
while cell.first().is_some_and(&is_edge_trivia) {
cell.remove(0);
}
while cell.last().is_some_and(&is_edge_trivia) {
cell.pop();
}
let (span, align) = detect_multicolumn(cell);
let mut content = cell
.iter()
.filter(|element| !is_collapsible_trivia_element(element));
let caption = !math
&& content
.next()
.and_then(SyntaxElement::as_node)
.is_some_and(|node| {
node.kind() == SyntaxKind::COMMAND
&& matches!(
command_name(node).as_deref(),
Some("caption" | "caption*" | "captionof" | "captionof*")
)
})
&& content.next().is_none();
if cell.iter().any(|e| {
e.as_token()
.is_some_and(|t| t.kind() == SyntaxKind::COMMENT)
}) {
return None;
}
let first_block = if math {
cell.iter().position(|e| {
e.as_node().is_some()
&& lower_math_element(e.clone(), cx, MathSpacing::Normal)
.contains_forced_break()
})
} else {
None
};
let block_eligible = first_block.is_some()
&& !cell.iter().filter_map(|e| e.as_node()).any(|n| {
n.descendants()
.any(|d| d.kind() == SyntaxKind::ENVIRONMENT && has_verbatim_body(&d))
})
&& !cell_has_blank_line(cell);
let hang = match first_block.filter(|_| block_eligible) {
None | Some(0) => 0,
Some(i) => {
let prefix =
lower_math_seq(cell[..i].iter().cloned(), cx, MathSpacing::Normal, false);
let width = printer.print_flat(&prefix).trim().chars().count();
if width == 0 { 0 } else { width + 1 }
}
};
let ir = if math {
lower_math_seq(cell.drain(..), cx, MathSpacing::Normal, false)
} else {
let joined = lower_element_stream(cell.drain(..), cx)
.into_iter()
.map(|ir| {
if matches!(ir, Ir::HardLine) {
Ir::line()
} else {
ir
}
})
.collect::<Vec<_>>();
Ir::concat(joined)
};
if ir.contains_forced_break() {
if !block_eligible {
return None;
}
cells.push(Cell {
text: String::new(),
span,
caption,
align,
block: Some(BlockCell { hang, ir }),
});
return Some(());
}
printer.flat_width(&ir)?;
cells.push(Cell {
text: printer.print_flat(&ir).trim().to_string(),
span,
caption,
align,
block: None,
});
Some(())
}
fn detect_multicolumn(cell: &[SyntaxElement]) -> (usize, Option<ColAlign>) {
let mut content = cell.iter().filter(|e| {
!e.as_token()
.is_some_and(|t| is_collapsible_trivia(t.kind()))
});
let Some(first) = content.next() else {
return (1, None);
};
if content.next().is_some() {
return (1, None);
}
let Some(node) = first.as_node() else {
return (1, None);
};
if node.kind() != SyntaxKind::COMMAND
|| command_name(node).as_deref() != Some("multicolumn")
{
return (1, None);
}
let span = crate::ast::nth_group_text(node, 0)
.and_then(|t| t.trim().parse::<usize>().ok())
.filter(|&n| n >= 1);
let align = crate::ast::nth_group(node, 1)
.map(|g| crate::ast::group_inner_source(&g))
.and_then(|s| colspec::parse_column_spec(&s))
.and_then(|v| v.first().copied());
(span.unwrap_or(1), align)
}
let mut items: Vec<GridItem> = Vec::new();
let mut cells: Vec<Cell> = Vec::new();
let mut cell: Vec<SyntaxElement> = Vec::new();
let mut idx = 0;
let mut leading = math;
while idx < inline.len() {
let at_boundary = cells.is_empty() && cell_is_blank(&cell);
if math && let Some((mut text, tail)) = grid_intertext(&inline[idx], cell_cx) {
if !at_boundary {
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
items.push(GridItem::Row(AlignRow {
cells: std::mem::take(&mut cells),
line_break: None,
trailing_comment: None,
}));
}
cell.clear();
inline.splice(idx + 1..idx + 1, tail);
idx += 1;
let mut comment_idx = idx;
while inline
.get(comment_idx)
.is_some_and(|element| element.kind() == SyntaxKind::WHITESPACE)
{
comment_idx += 1;
}
if let Some(token) = inline.get(comment_idx).and_then(SyntaxElement::as_token)
&& token.kind() == SyntaxKind::COMMENT
{
text = Ir::concat([text, Ir::text(" "), Ir::verbatim(token.text().trim_end())]);
idx = comment_idx + 1;
}
items.push(GridItem::Intertext(text));
leading = false;
continue;
}
if at_boundary
&& is_comment_or_rule_start(&inline[idx], cx)
&& let Some(line) = non_row_line(&inline, idx, &printer, cx)
{
let own_line = cell_has_newline(&cell);
let prev_is_row = matches!(items.last(), Some(GridItem::Row(_)));
if own_line || !prev_is_row {
items.push(GridItem::Passthrough(line.text));
cell.clear();
idx = line.next;
continue;
}
if line.has_rule {
items.push(GridItem::Passthrough(line.text));
} else if let Some(GridItem::Row(row)) = items.last_mut() {
row.trailing_comment = Some(line.text);
}
cell.clear();
idx = line.next;
continue;
}
if leading
&& at_boundary
&& let Some((text, next)) = leading_grid_label(&inline, idx, &printer, cell_cx)
{
items.push(GridItem::Passthrough(text));
cell.clear();
idx = next;
continue;
}
if !is_collapsible_trivia_element(&inline[idx]) {
leading = false;
}
match &inline[idx] {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::AMPERSAND => {
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
if cells.last().is_some_and(|c| c.block.is_some()) {
return None;
}
}
SyntaxElement::Node(child) if child.kind() == SyntaxKind::LINE_BREAK => {
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
let line_break = printer
.print_flat(&lower_node(child, cx))
.trim()
.to_string();
items.push(GridItem::Row(AlignRow {
cells: std::mem::take(&mut cells),
line_break: Some(line_break),
trailing_comment: None,
}));
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => {
let before_intertext = math
&& inline[idx + 1..]
.iter()
.find(|element| {
!is_collapsible_trivia_element(element)
&& element.kind() != SyntaxKind::COMMENT
})
.is_some_and(|element| grid_intertext(element, cell_cx).is_some());
if before_intertext {
let own_line = cell
.iter()
.rev()
.take_while(|element| is_collapsible_trivia_element(element))
.any(|element| element.kind() == SyntaxKind::NEWLINE);
let text = token.text().trim_end().to_string();
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
items.push(GridItem::Row(AlignRow {
cells: std::mem::take(&mut cells),
line_break: None,
trailing_comment: (!own_line).then(|| text.clone()),
}));
if own_line {
items.push(GridItem::Passthrough(text));
}
idx += 1;
continue;
}
if !rest_is_trivia_and_comment_lines(&inline, idx + 1) {
return None;
}
let text = token.text().trim_end().to_string();
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
items.push(GridItem::Row(AlignRow {
cells: std::mem::take(&mut cells),
line_break: None,
trailing_comment: Some(text),
}));
}
_ => cell.push(inline[idx].clone()),
}
idx += 1;
}
finish_cell(&mut cell, &mut cells, &printer, cell_cx, math)?;
let final_is_empty = cells.len() == 1
&& cells[0].text.is_empty()
&& cells[0].block.is_none()
&& cells[0].span == 1;
if !final_is_empty {
items.push(GridItem::Row(AlignRow {
cells,
line_break: None,
trailing_comment: None,
}));
}
Some(items)
}
fn grid_intertext(element: &SyntaxElement, cx: LowerCtx<'_>) -> Option<(Ir, Vec<SyntaxElement>)> {
let command = Command::cast(element.as_node()?.clone())?;
if !matches!(command.name()?.as_str(), "intertext" | "shortintertext")
|| cx.suppressed(command.syntax().text_range())
{
return None;
}
let signature = cx.signatures.command_at(command.syntax())?;
if signature.args.len() != 1
|| !signature.args[0].required
|| signature.args[0].kind != ArgKind::Brace
{
return None;
}
let children: Vec<_> = command.syntax().children_with_tokens().collect();
let argument = children
.iter()
.position(|child| matches!(child.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL))?;
if children[argument].kind() != SyntaxKind::GROUP
|| children[..argument].iter().any(|child| {
!matches!(
child.kind(),
SyntaxKind::CONTROL_WORD | SyntaxKind::DOC_COMMENT
) && !is_collapsible_trivia_element(child)
})
{
return None;
}
let mut text = lower_element_stream(
children[..argument]
.iter()
.filter(|child| !is_collapsible_trivia_element(child))
.cloned(),
cx,
);
text.push(lower_node(children[argument].as_node()?, cx));
Some((Ir::concat(text), children[argument + 1..].to_vec()))
}
fn leading_grid_label(
inline: &[SyntaxElement],
start: usize,
printer: &Printer,
cx: LowerCtx<'_>,
) -> Option<(String, usize)> {
let (label, rest) = split_leading_label(&inline[start..])?;
let command = Command::cast(label.as_node()?.clone())?;
let node = command.syntax();
if command.groups().count() != 1
|| command.optionals().next().is_some()
|| cx.suppressed(node.text_range())
{
return None;
}
let comment = node
.children()
.find(|child| child.kind() == SyntaxKind::DOC_COMMENT);
let label_cx = LowerCtx {
omitted_leading_comment: comment.as_ref().map(SyntaxNode::text_range),
..cx
};
let ir = lower_math_element(label, label_cx, MathSpacing::Normal);
printer.flat_width(&ir)?;
let mut text = comment
.map(|comment| printer.print_flat(&lower_node(&comment, cx)))
.unwrap_or_default();
text.push_str(printer.print_flat(&ir).trim());
let mut next = inline.len() - rest.len();
let mut comment_idx = next;
while inline.get(comment_idx).is_some_and(|element| {
element
.as_token()
.is_some_and(|token| token.kind() == SyntaxKind::WHITESPACE)
}) {
comment_idx += 1;
}
if let Some(token) = inline.get(comment_idx).and_then(SyntaxElement::as_token)
&& token.kind() == SyntaxKind::COMMENT
{
text.push(' ');
text.push_str(token.text().trim_end());
next = comment_idx + 1;
}
Some((text, next))
}
struct NonRowLine {
text: String,
next: usize,
has_rule: bool,
}
fn non_row_line(
inline: &[SyntaxElement],
start: usize,
printer: &Printer,
cx: LowerCtx<'_>,
) -> Option<NonRowLine> {
let mut i = start;
let mut content_end = start;
let mut has_rule = false;
let mut has_comment = false;
while i < inline.len() {
match &inline[i] {
SyntaxElement::Token(t) if t.kind() == SyntaxKind::NEWLINE => break,
SyntaxElement::Token(t) if t.kind() == SyntaxKind::WHITESPACE => {}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => {
has_comment = true;
i += 1;
content_end = i;
break;
}
SyntaxElement::Node(n) if n.kind() == SyntaxKind::COMMAND && is_rule_command(n, cx) => {
has_rule = true;
i += 1;
content_end = i;
continue;
}
SyntaxElement::Token(t) if token_is_rule_word(t, cx) => {
has_rule = true;
i += 1;
content_end = i;
continue;
}
SyntaxElement::Token(t) if has_rule && is_paren_trim_word(t) => {
i += 1;
content_end = i;
continue;
}
SyntaxElement::Node(n) if has_rule && n.kind() == SyntaxKind::GROUP => {
i += 1;
content_end = i;
continue;
}
_ => return None,
}
i += 1;
}
if !(has_rule || has_comment) {
return None;
}
let mut next = content_end;
while next < inline.len() {
match &inline[next] {
SyntaxElement::Token(t) if t.kind() == SyntaxKind::WHITESPACE => next += 1,
SyntaxElement::Token(t) if t.kind() == SyntaxKind::NEWLINE => {
next += 1;
break;
}
_ => break,
}
}
let ir = Ir::concat(lower_element_stream(
inline[start..content_end].iter().cloned(),
cx,
));
let text = printer.print_flat(&ir).trim().to_string();
Some(NonRowLine {
text,
next,
has_rule,
})
}
fn is_comment_or_rule_start(element: &SyntaxElement, cx: LowerCtx<'_>) -> bool {
match element {
SyntaxElement::Token(t) => t.kind() == SyntaxKind::COMMENT || token_is_rule_word(t, cx),
SyntaxElement::Node(n) => n.kind() == SyntaxKind::COMMAND && is_rule_command(n, cx),
}
}
fn token_is_rule_word(token: &SyntaxToken, cx: LowerCtx<'_>) -> bool {
token.kind() == SyntaxKind::CONTROL_WORD
&& cx
.signatures
.command(token.text().trim_start_matches('\\'))
.is_some_and(|sig| sig.rule)
}
pub fn is_paren_trim_word(token: &SyntaxToken) -> bool {
if token.kind() != SyntaxKind::WORD {
return false;
}
let t = token.text();
t.len() >= 3
&& t.starts_with('(')
&& t.ends_with(')')
&& t[1..t.len() - 1].chars().all(|c| c == 'l' || c == 'r')
}
fn is_rule_command(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures.command_at(node).is_some_and(|sig| sig.rule)
}
fn cell_is_blank(cell: &[SyntaxElement]) -> bool {
cell.iter().all(|e| {
e.as_token()
.is_some_and(|t| is_collapsible_trivia(t.kind()))
})
}
fn cell_has_blank_line(cell: &[SyntaxElement]) -> bool {
let mut run_newlines = 0;
for e in cell {
match e.as_token().map(SyntaxToken::kind) {
Some(SyntaxKind::NEWLINE) => {
run_newlines += 1;
if run_newlines >= 2 {
return true;
}
}
Some(SyntaxKind::WHITESPACE) => {}
_ => run_newlines = 0,
}
}
false
}
fn cell_has_newline(cell: &[SyntaxElement]) -> bool {
cell.iter().any(|e| {
e.as_token()
.is_some_and(|t| t.kind() == SyntaxKind::NEWLINE)
})
}
fn rest_is_trivia_and_comment_lines(inline: &[SyntaxElement], from: usize) -> bool {
let mut own_line = false;
for element in &inline[from..] {
let Some(token) = element.as_token() else {
return false;
};
match token.kind() {
SyntaxKind::NEWLINE => own_line = true,
SyntaxKind::WHITESPACE => {}
SyntaxKind::COMMENT if own_line => own_line = false,
_ => return false,
}
}
true
}
fn flatten_alignment_body(
body_elements: &[SyntaxElement],
cx: LowerCtx<'_>,
math: bool,
) -> Option<Vec<SyntaxElement>> {
let wrapper = if math {
SyntaxKind::MATH
} else {
SyntaxKind::PARAGRAPH
};
let mut inline: Vec<SyntaxElement> = Vec::new();
let mut paragraphs = 0;
for element in strip_virtual_dtx_framing(body_elements.iter().cloned(), cx) {
match element {
SyntaxElement::Node(child) if child.kind() == wrapper => {
paragraphs += 1;
if paragraphs > 1 {
return None;
}
extend_alignment_elements(&mut inline, child.children_with_tokens(), cx);
}
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {}
other => push_alignment_element(&mut inline, other, cx),
}
}
Some(inline)
}
fn extend_alignment_elements(
inline: &mut Vec<SyntaxElement>,
elements: impl IntoIterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
) {
for element in strip_virtual_dtx_framing(elements, cx) {
push_alignment_element(inline, element, cx);
}
}
fn push_alignment_element(
inline: &mut Vec<SyntaxElement>,
element: SyntaxElement,
cx: LowerCtx<'_>,
) {
if let SyntaxElement::Node(node) = &element
&& rule_overattaches_cell(node, cx)
{
extend_alignment_elements(inline, node.children_with_tokens(), cx);
} else {
inline.push(element);
}
}
fn rule_overattaches_cell(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if node.kind() != SyntaxKind::COMMAND || !is_rule_command(node, cx) {
return false;
}
let Some(first_arg) = node
.children()
.find(|child| matches!(child.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL))
else {
return false;
};
if first_arg.kind() != SyntaxKind::GROUP {
return false;
}
let first_slot_is_brace = cx
.signatures
.command_at(node)
.and_then(|sig| sig.args.first())
.is_some_and(|arg| arg.kind == ArgKind::Brace);
!first_slot_is_brace
}
fn column_alignments(env: &SyntaxNode, cx: LowerCtx<'_>) -> Option<Vec<ColAlign>> {
let begin = Environment::cast(env.clone())?.begin()?;
if !cx
.signatures
.environment_at(begin.syntax())
.is_some_and(|sig| sig.align)
{
return None;
}
let spec = crate::ast::children::<Group>(begin.syntax()).last()?;
colspec::parse_column_spec(&spec.inner_source())
}
fn render_alignment_rows(items: &[GridItem], aligns: &[ColAlign]) -> Ir {
const SEP: &str = " & ";
let mut col_widths: Vec<usize> = Vec::new();
let mut widen = |c: usize, width: usize| {
while c >= col_widths.len() {
col_widths.push(0);
}
if width > col_widths[c] {
col_widths[c] = width;
}
};
for item in items {
let GridItem::Row(row) = item else { continue };
if row.cells.len() == 1 && row.cells[0].caption {
continue;
}
let mut c = 0;
for cell in &row.cells {
if cell.span == 1 && cell.block.is_none() {
widen(c, cell.text.chars().count());
}
c += cell.span;
}
}
let field_width = |c: usize, span: usize| -> usize {
let sum: usize = (c..c + span)
.map(|i| col_widths.get(i).copied().unwrap_or(0))
.sum();
sum + SEP.len() * (span - 1)
};
let grid_width =
col_widths.iter().sum::<usize>() + SEP.len() * col_widths.len().saturating_sub(1);
let grid_width = grid_width.saturating_sub(usize::from(
col_widths.len() > 1 && col_widths.first() == Some(&0),
));
let lines = items.iter().map(|item| {
let row = match item {
GridItem::Intertext(ir) => return ir.clone(),
GridItem::Passthrough(text) => {
return Ir::join(
Ir::hard_line(),
text.lines().map(|line| Ir::text(line.trim().to_string())),
);
}
GridItem::Row(row) => row,
};
let caption = row.cells.len() == 1 && row.cells[0].caption;
let mut line = String::new();
let mut block: Option<Ir> = None;
let last = row.cells.len().saturating_sub(1);
let mut c = 0;
for (idx, cell) in row.cells.iter().enumerate() {
if idx > 0 {
line.push_str(if line.is_empty() { "& " } else { SEP });
}
if let Some(block_cell) = &cell.block {
block = Some(Ir::align(
line.chars().count() + block_cell.hang,
block_cell.ir.clone(),
));
break;
}
let field = if caption {
0
} else {
field_width(c, cell.span)
};
let text_width = cell.text.chars().count();
let pad = field.saturating_sub(text_width);
let align = cell
.align
.unwrap_or_else(|| aligns.get(c).copied().unwrap_or(ColAlign::Left));
let (leading, trailing) = match align {
ColAlign::Left => (0, pad),
ColAlign::Right => (pad, 0),
ColAlign::Center => (pad / 2, pad - pad / 2),
};
let trailing = if idx == last { 0 } else { trailing };
line.push_str(&" ".repeat(leading));
line.push_str(&cell.text);
line.push_str(&" ".repeat(trailing));
c += cell.span;
}
let mut tail = String::new();
if let Some(line_break) = &row.line_break {
if block.is_none() && !caption {
line.push_str(&" ".repeat(grid_width.saturating_sub(line.chars().count())));
}
tail.push(' ');
tail.push_str(line_break);
}
if let Some(comment) = &row.trailing_comment {
tail.push(' ');
tail.push_str(comment);
}
match block {
Some(block) => Ir::concat([Ir::text(line), block, Ir::text(tail)]),
None => {
line.push_str(&tail);
Ir::text(line)
}
}
});
Ir::join(Ir::hard_line(), lines)
}
fn lower_bracketed(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
keyval: bool,
) -> Ir {
let mut open_ir = Ir::Nil;
let mut close_ir = Ir::Nil;
let mut body_elements: Vec<SyntaxElement> = Vec::new();
for element in strip_virtual_dtx_framing(node.children_with_tokens(), cx) {
match &element {
SyntaxElement::Token(t) if t.kind() == open && matches!(open_ir, Ir::Nil) => {
open_ir = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == close => {
close_ir = Ir::verbatim(t.text());
}
_ => body_elements.push(element),
}
}
let preserve_blank_edges = open == SyntaxKind::L_BRACKET;
let leading_blank = preserve_blank_edges
&& body_elements
.iter()
.take_while(|element| is_collapsible_trivia_element(element))
.filter(|element| element.kind() == SyntaxKind::NEWLINE)
.count()
>= 2;
let trailing_blank = preserve_blank_edges
&& body_elements
.iter()
.rev()
.take_while(|element| is_collapsible_trivia_element(element))
.filter(|element| element.kind() == SyntaxKind::NEWLINE)
.count()
>= 2;
let has_leading_comment = body_elements
.first()
.and_then(SyntaxElement::as_token)
.is_some_and(|t| t.kind() == SyntaxKind::COMMENT);
let open_ir = if has_leading_comment {
let comment = body_elements.remove(0);
Ir::concat([open_ir, Ir::verbatim(comment.as_token().unwrap().text())])
} else {
open_ir
};
let open_glued = !keyval
&& body_elements
.first()
.and_then(SyntaxElement::as_token)
.is_none_or(|t| !is_collapsible_trivia(t.kind()));
let close_glued = !keyval
&& body_elements.last().is_some_and(|element| {
element
.as_token()
.is_none_or(|token| !is_collapsible_trivia(token.kind()))
});
let body =
if matches!(cx.wrap, WrapMode::Reflow | WrapMode::Stable) && open == SyntaxKind::L_BRACE {
reflow_elements(body_elements.into_iter(), cx, ReflowKind::Statement)
} else {
Ir::concat(lower_element_stream(body_elements.into_iter(), cx))
};
let body = trim_trailing_break(trim_leading_break(body));
if matches!(body, Ir::Nil) {
if leading_blank || trailing_blank {
Ir::concat([open_ir, Ir::empty_line(), close_ir])
} else if has_leading_comment {
Ir::concat([open_ir, Ir::hard_line(), close_ir])
} else {
Ir::concat([open_ir, close_ir])
}
} else {
let lead = if leading_blank {
Ir::empty_line()
} else if open_glued {
Ir::Nil
} else {
Ir::hard_line()
};
let trail = if trailing_blank {
Ir::empty_line()
} else if close_glued {
Ir::Nil
} else {
Ir::hard_line()
};
Ir::concat([
open_ir,
Ir::indent(Ir::concat([lead, body])),
trail,
close_ir,
])
}
}
fn opaque_group_has_glued_environment_sibling(node: &SyntaxNode) -> bool {
let elements: Vec<SyntaxElement> = node.children_with_tokens().collect();
elements.iter().enumerate().any(|(index, element)| {
let SyntaxElement::Node(child) = element else {
return false;
};
if child.kind() != SyntaxKind::ENVIRONMENT {
return false;
}
let left = index
.checked_sub(1)
.and_then(|previous| elements.get(previous));
glued_group_content(left, SyntaxKind::L_BRACE)
|| glued_group_content(elements.get(index + 1), SyntaxKind::R_BRACE)
})
}
fn glued_group_content(element: Option<&SyntaxElement>, delimiter: SyntaxKind) -> bool {
match element {
Some(SyntaxElement::Node(_)) => true,
Some(SyntaxElement::Token(token)) => token.kind() != delimiter && !is_trivia(token.kind()),
None => false,
}
}
fn lower_opaque_group(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
fn commit_gap(atoms: &mut Vec<Ir>, atom: &mut Vec<Ir>, pending: &mut Option<(String, bool)>) {
if let Some((gap, _)) = pending.take() {
if gap == " " {
if !atom.is_empty() {
atoms.push(Ir::concat(std::mem::take(atom)));
}
} else {
atom.push(Ir::verbatim(gap));
}
}
}
let block = || lower_bracketed(node, SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, cx, false);
if plain_opaque_block_has_authored_rows(node, cx) {
return block();
}
let mut open = Ir::Nil;
let mut close = Ir::Nil;
let mut lead: Option<String> = None;
let mut atoms: Vec<Ir> = Vec::new();
let mut atom: Vec<Ir> = Vec::new();
let mut pending: Option<(String, bool)> = None;
let mut iter = alignment_cell_elements(node.children_with_tokens(), cx)
.into_iter()
.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(t)
if t.kind() == SyntaxKind::L_BRACE && matches!(open, Ir::Nil) =>
{
open = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::R_BRACE => {
close = Ir::verbatim(t.text());
}
SyntaxElement::Token(t)
if cx.in_dtx_doc_region && t.kind() == SyntaxKind::DOC_MARGIN =>
{
while matches!(
iter.peek(),
Some(SyntaxElement::Token(next)) if next.kind() == SyntaxKind::WHITESPACE
) {
iter.next();
}
}
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
let gap = consume_gap(&t, &mut iter);
let blank = gap == Gap::Blank;
let flat = gap.flat().to_string();
if atoms.is_empty() && atom.is_empty() {
lead = Some(flat);
} else {
pending = Some((flat, blank));
}
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => return block(),
SyntaxElement::Token(t) if t.text().contains('\n') => return block(),
SyntaxElement::Token(t) => {
if matches!(pending, Some((_, true))) {
return block(); }
commit_gap(&mut atoms, &mut atom, &mut pending);
atom.push(lower_loose_token(&t, cx));
}
SyntaxElement::Node(child) => {
let ir = lower_node(&child, cx);
if ir.contains_forced_break() {
return block(); }
if matches!(pending, Some((_, true))) {
return block(); }
commit_gap(&mut atoms, &mut atom, &mut pending);
atom.push(ir);
}
}
}
let trail: Option<String> = pending.take().map(|(gap, _)| gap);
if !atom.is_empty() {
atoms.push(Ir::concat(atom));
}
if atoms.is_empty() {
let lead = lead.map(Ir::verbatim).unwrap_or(Ir::Nil);
return Ir::concat([open, lead, close]);
}
let mut parts: Vec<Ir> = vec![open];
let mut inner: Vec<Ir> = Vec::new();
match lead.as_deref() {
None => {}
Some(" ") => {
inner.push(Ir::soft_line());
inner.push(Ir::if_break(Ir::verbatim(" "), Ir::Nil));
}
Some(other) => parts.push(Ir::verbatim(other)),
}
inner.push(Ir::fill(atoms));
parts.push(Ir::indent(Ir::concat(inner)));
match trail.as_deref() {
None => {}
Some(" ") => {
parts.push(Ir::if_break(Ir::verbatim(" "), Ir::Nil));
parts.push(Ir::soft_line());
}
Some(other) => parts.push(Ir::verbatim(other)),
}
parts.push(close);
Ir::group(Ir::concat(parts))
}
fn lower_beamer_body(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let cx = LowerCtx {
wrap: WrapMode::Preserve,
..cx
};
let mut elements: Vec<_> = node.children_with_tokens().collect();
let close = elements.pop().expect("a parsed group has a closer");
let open = elements.remove(0);
let trailing = elements
.iter()
.rposition(|element| !is_collapsible_trivia_element(element))
.map_or(0, |index| index + 1);
let closing_gap = elements.split_off(trailing);
Ir::concat([
Ir::verbatim(open.to_string()),
Ir::indent(Ir::concat(lower_element_stream(elements.into_iter(), cx))),
Ir::concat(lower_element_stream(closing_gap.into_iter(), cx)),
Ir::verbatim(close.to_string()),
])
}
fn plain_opaque_block_has_authored_rows(group: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if cx.in_dtx_doc_region {
return false;
}
let Some(command) = group
.parent()
.filter(|node| node.kind() == SyntaxKind::COMMAND)
else {
return false;
};
let Some(paragraph) = command
.parent()
.filter(|node| node.kind() == SyntaxKind::PARAGRAPH)
else {
return false;
};
if is_dtx_doc_paragraph(¶graph) {
return false;
}
let mut content = paragraph
.children_with_tokens()
.filter(|element| !is_collapsible_trivia_element(element));
if !content
.next()
.is_some_and(|element| element.as_node() == Some(&command))
|| content.next().is_some()
{
return false;
}
let elements: Vec<SyntaxElement> = group.children_with_tokens().collect();
if !elements.iter().all(|element| match element {
SyntaxElement::Token(token) => matches!(
token.kind(),
SyntaxKind::L_BRACE
| SyntaxKind::R_BRACE
| SyntaxKind::WORD
| SyntaxKind::WHITESPACE
| SyntaxKind::NEWLINE
),
SyntaxElement::Node(node) => node.kind() == SyntaxKind::LINE_BREAK,
}) {
return false;
}
let mut saw_line_break = false;
for (index, element) in elements.iter().enumerate() {
if !matches!(element, SyntaxElement::Node(node) if node.kind() == SyntaxKind::LINE_BREAK) {
continue;
}
saw_line_break = true;
let left_is_word = elements[..index]
.iter()
.rev()
.find(|element| !is_collapsible_trivia_element(element))
.is_some_and(
|element| matches!(element, SyntaxElement::Token(t) if t.kind() == SyntaxKind::WORD),
);
let mut newlines = 0usize;
let right = elements[index + 1..].iter().find(|element| {
if let SyntaxElement::Token(token) = element
&& is_collapsible_trivia(token.kind())
{
newlines += usize::from(token.kind() == SyntaxKind::NEWLINE);
false
} else {
true
}
});
let right_is_word = right.is_some_and(
|element| matches!(element, SyntaxElement::Token(t) if t.kind() == SyntaxKind::WORD),
);
if !left_is_word || newlines != 1 || !right_is_word {
return false;
}
}
saw_line_break
}
fn lower_optional(node: &SyntaxNode, cx: LowerCtx<'_>, keyval: bool) -> Option<Ir> {
lower_segmented_group(
node,
SyntaxKind::L_BRACKET,
SyntaxKind::R_BRACKET,
cx,
keyval,
)
}
fn lower_column_spec_group(node: &SyntaxNode, cx: LowerCtx<'_>) -> Option<Ir> {
if !cx.wraps_prose()
|| (!cx.in_dtx_doc_region
&& (contains_doc_margin(node, cx) || doc_margin_opens_line(node, cx)))
{
return None;
}
let mut open = Ir::Nil;
let mut close = Ir::Nil;
let mut entries: Vec<Ir> = Vec::new();
let mut current: Vec<Ir> = Vec::new();
let mut pending_gap: Option<Gap> = None;
let mut bracket_depth = 0usize;
let mut iter = strip_virtual_dtx_framing(node.children_with_tokens(), cx)
.into_iter()
.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(token)
if token.kind() == SyntaxKind::L_BRACE && matches!(open, Ir::Nil) =>
{
open = Ir::verbatim(token.text());
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::R_BRACE => {
close = Ir::verbatim(token.text());
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::L_BRACKET => {
if let Some(gap) = pending_gap.take() {
current.push(Ir::verbatim(gap.flat()));
}
bracket_depth += 1;
current.push(lower_loose_token(&token, cx));
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::R_BRACKET => {
bracket_depth = bracket_depth.saturating_sub(1);
current.push(lower_loose_token(&token, cx));
}
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
let gap = consume_gap(&token, &mut iter);
if gap == Gap::Blank {
return None;
}
if bracket_depth == 0 {
pending_gap = Some(gap);
} else {
current.push(Ir::verbatim(gap.flat()));
}
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::COMMENT => return None,
SyntaxElement::Token(token) => {
if let Some(gap) = pending_gap.take()
&& !current.is_empty()
{
entries.push(Ir::concat(std::mem::take(&mut current)));
entries.push(gap.separator());
}
current.push(lower_loose_token(&token, cx));
}
SyntaxElement::Node(child) => {
let ir = lower_node(&child, cx);
if ir.contains_forced_break() {
return None;
}
if let Some(gap) = pending_gap.take() {
current.push(Ir::verbatim(gap.flat()));
}
current.push(ir);
}
}
}
entries.push(Ir::concat(current));
while entries.last().is_some_and(is_segment_separator) {
entries.pop();
}
let splits = entries.iter().filter(|ir| is_segment_separator(ir)).count();
if splits == 0 {
return None;
}
Some(Ir::group(Ir::concat([
open,
Ir::indent(Ir::concat([Ir::soft_line(), Ir::concat(entries)])),
Ir::soft_line(),
close,
])))
}
fn lower_segmented_group(
node: &SyntaxNode,
open_kind: SyntaxKind,
close_kind: SyntaxKind,
cx: LowerCtx<'_>,
keyval: bool,
) -> Option<Ir> {
if node.next_sibling().is_some_and(|sibling| {
sibling.kind() == SyntaxKind::GROUP
&& sibling
.descendants_with_tokens()
.filter_map(SyntaxElement::into_token)
.any(|token| token.kind() == SyntaxKind::VERB)
}) {
return None;
}
if !cx.wraps_prose()
|| (!cx.in_dtx_doc_region
&& (contains_doc_margin(node, cx) || doc_margin_opens_line(node, cx)))
{
return spans_multiple_lines(node)
.then(|| lower_bracketed(node, open_kind, close_kind, cx, keyval));
}
let Some(segments) = segment_delimited_body(node, open_kind, close_kind, cx, keyval) else {
return Some(lower_bracketed(node, open_kind, close_kind, cx, keyval));
};
let GroupSegments {
open,
mut parts,
close,
splits,
} = segments;
let lead = peel_padding(&mut parts, Edge::Leading);
let trail = peel_padding(&mut parts, Edge::Trailing);
if splits == 0 {
return Some(if keyval {
Ir::concat([open, Ir::concat(parts), close])
} else {
Ir::concat([open, lead, Ir::concat(parts), trail, close])
});
}
if !keyval {
let edge = |padding: Ir| match &padding {
Ir::Verbatim { text, .. } if text.as_ref() == " " => Ir::line(),
_ => padding,
};
let atoms = parts
.split(is_segment_separator)
.map(|entry| Ir::concat(entry.iter().cloned()));
return Some(Ir::group(Ir::concat([
open,
Ir::indent(Ir::concat([edge(lead), Ir::fill(atoms)])),
edge(trail),
close,
])));
}
let body = Ir::concat(parts);
Some(Ir::group(Ir::concat([
open,
Ir::indent(Ir::concat([Ir::soft_line(), body])),
Ir::soft_line(),
close,
])))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Edge {
Leading,
Trailing,
}
fn peel_padding(parts: &mut Vec<Ir>, edge: Edge) -> Ir {
let mut padding = Ir::Nil;
loop {
let at = match edge {
Edge::Leading => 0,
Edge::Trailing => parts.len().saturating_sub(1),
};
match parts.get(at) {
Some(ir) if is_trimmable_break(ir) => {
let taken = parts.remove(at);
if matches!(padding, Ir::Nil) {
padding = taken;
}
}
_ => return padding,
}
}
}
struct GroupSegments {
open: Ir,
parts: Vec<Ir>,
close: Ir,
splits: usize,
}
fn segment_delimited_body(
node: &SyntaxNode,
open_kind: SyntaxKind,
close_kind: SyntaxKind,
cx: LowerCtx<'_>,
normalize_commas: bool,
) -> Option<GroupSegments> {
let mut open = Ir::Nil;
let mut close = Ir::Nil;
let mut parts: Vec<Ir> = Vec::new();
let mut splits = 0usize;
let mut depth = 0usize;
let mut open_entry = false;
let mut entry_open = false;
let mut iter = strip_virtual_dtx_framing(node.children_with_tokens(), cx)
.into_iter()
.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(t) if t.kind() == open_kind && matches!(open, Ir::Nil) => {
open = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == close_kind => {
close = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::L_BRACKET => {
depth += 1;
open_entry = false;
entry_open = true;
parts.push(Ir::verbatim(t.text()));
}
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
let gap = consume_gap(&t, &mut iter);
if gap == Gap::Blank {
return None; }
if open_entry && depth == 0 {
parts.push(if normalize_commas {
tight_line()
} else {
gap.separator()
});
splits += 1;
entry_open = false;
} else {
parts.push(Ir::verbatim(gap.flat()));
}
open_entry = false;
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => return None,
SyntaxElement::Token(t) if t.kind() == SyntaxKind::WORD && depth == 0 => {
if normalize_commas && t.text().starts_with(',') {
let _ = peel_padding(&mut parts, Edge::Trailing);
}
splits += push_entry_word(t.text(), normalize_commas, &mut parts, entry_open);
open_entry = t.text().ends_with(',');
entry_open = !open_entry;
}
SyntaxElement::Token(t) => {
parts.push(lower_loose_token(&t, cx));
open_entry = false;
entry_open = true;
}
SyntaxElement::Node(child) => {
let ir = lower_node(&child, cx);
if ir.contains_forced_break() {
return None; }
parts.push(ir);
open_entry = false;
entry_open = true;
}
}
}
let mut dropped_gap = false;
while parts.last().is_some_and(is_segment_separator) {
dropped_gap |= matches!(parts.last(), Some(Ir::Line));
parts.pop();
splits = splits.saturating_sub(1);
}
if dropped_gap {
parts.push(Ir::verbatim(" "));
}
Some(GroupSegments {
open,
parts,
close,
splits,
})
}
fn push_entry_word(
text: &str,
normalize_commas: bool,
parts: &mut Vec<Ir>,
entry_open: bool,
) -> usize {
if !normalize_commas || !text.contains(',') {
parts.push(Ir::verbatim(text));
return 0;
}
let mut splits = 0usize;
let mut start = 0usize;
let mut pushed = 0usize;
let mut has_content = entry_open;
for (i, _) in text.match_indices(',') {
let piece = &text[start..=i];
if piece.len() == 1 && !has_content {
continue; }
if pushed > 0 {
parts.push(tight_line());
splits += 1;
}
parts.push(Ir::verbatim(piece));
pushed += 1;
start = i + 1;
has_content = false;
}
if start < text.len() {
if pushed > 0 {
parts.push(tight_line());
splits += 1;
}
parts.push(Ir::verbatim(&text[start..]));
}
splits
}
fn tight_line() -> Ir {
Ir::tight_line()
}
fn is_segment_separator(ir: &Ir) -> bool {
matches!(ir, Ir::Line | Ir::TightLine | Ir::SoftLine)
}
fn command_has_managed_arg(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures.command_at(command).is_some_and(|sig| {
sig.args
.iter()
.any(|spec| spec.content != ContentKind::Opaque)
})
}
fn command_has_math_arg(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures.command_at(command).is_some_and(|sig| {
sig.args
.iter()
.any(|spec| spec.domain == ArgumentDomain::Math)
})
}
fn command_is_inline_prose(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures.command_at(command).is_some_and(|sig| {
sig.inline
&& sig
.args
.iter()
.any(|spec| spec.content == ContentKind::Prose)
})
}
fn command_is_inline(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.command_at(command)
.is_some_and(|sig| sig.inline)
}
fn command_citation_placement(command: &SyntaxNode, cx: LowerCtx<'_>) -> Option<CitationPlacement> {
cx.signatures.command_at(command).and_then(|sig| {
(sig.inline
&& sig
.args
.iter()
.any(|spec| spec.content == ContentKind::TokenList))
.then_some(sig.citation)
.flatten()
})
}
fn command_is_sectioning(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures
.command_at(command)
.is_some_and(|sig| sig.sectioning.is_some())
}
fn command_is_label(command: &SyntaxNode) -> bool {
command_name(command).as_deref() == Some("label")
}
fn command_is_block(command: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
cx.signatures.command_at(command).is_some_and(|sig| {
sig.block
&& (sig.args.iter().all(|arg| !arg.required) || command.children().next().is_some())
})
}
fn lower_statement(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let comment = statement_leading_comment(node, cx);
let body_cx = LowerCtx {
omitted_leading_comment: comment
.as_ref()
.map(SyntaxNode::text_range)
.or(cx.omitted_leading_comment),
..cx
};
let elements: Vec<SyntaxElement> = node.children_with_tokens().collect();
let prefix_end = statement_leading_command_comment_prefix(&elements, body_cx);
if comment.is_none() && prefix_end == 0 {
return Ir::indent(reflow_elements(
elements.into_iter(),
cx,
ReflowKind::StatementInterior,
));
}
let mut leading = Vec::new();
if let Some(comment) = comment {
leading.push(Ir::join(
Ir::hard_line(),
comment
.children_with_tokens()
.filter_map(SyntaxElement::into_token)
.filter(|token| token.kind() == SyntaxKind::COMMENT)
.map(|token| Ir::verbatim(token.text())),
));
}
if prefix_end > 0 {
if !leading.is_empty() {
leading.push(Ir::hard_line());
}
leading.push(reflow_elements(
elements[..prefix_end].iter().cloned(),
body_cx,
ReflowKind::StatementInterior,
));
}
let body = reflow_elements(
elements[prefix_end..].iter().cloned(),
body_cx,
ReflowKind::StatementInterior,
);
Ir::concat([Ir::concat(leading), Ir::hard_line(), Ir::indent(body)])
}
fn statement_leading_command_comment_prefix(elements: &[SyntaxElement], cx: LowerCtx<'_>) -> usize {
let mut prefix_end = 0;
let mut saw_command = false;
for (idx, element) in elements.iter().enumerate() {
match element {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::WHITESPACE => {}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::NEWLINE => {
if saw_command {
return prefix_end;
}
}
SyntaxElement::Node(node)
if node.kind() == SyntaxKind::COMMAND
&& !cx.suppressed(node.text_range())
&& !(cx.is_dtx && contains_indented_dtx_comment(node)) =>
{
saw_command = true;
}
SyntaxElement::Token(token)
if token.kind() == SyntaxKind::COMMENT
&& saw_command
&& !cx.suppressed(token.text_range()) =>
{
prefix_end = idx + 1;
saw_command = false;
}
_ => return prefix_end,
}
}
prefix_end
}
fn statement_leading_comment(node: &SyntaxNode, cx: LowerCtx<'_>) -> Option<SyntaxNode> {
let construct = node.first_child()?;
if cx.suppressed(construct.text_range())
|| cx.is_dtx && contains_indented_dtx_comment(&construct)
{
return None;
}
let comment = construct
.first_child()
.filter(|child| child.kind() == SyntaxKind::DOC_COMMENT)
.filter(|comment| comment.text_range().start() == node.text_range().start())?;
(!cx.suppressed(comment.text_range())).then_some(comment)
}
fn flatten_statements(elements: Vec<SyntaxElement>) -> Vec<SyntaxElement> {
if !elements.iter().any(|e| {
e.as_node()
.is_some_and(|n| n.kind() == SyntaxKind::STATEMENT)
}) {
return elements;
}
let mut out = Vec::with_capacity(elements.len());
for element in elements {
match &element {
SyntaxElement::Node(node) if node.kind() == SyntaxKind::STATEMENT => {
out.extend(node.children_with_tokens());
}
_ => out.push(element),
}
}
out
}
fn flatten_inline_prose(
elements: Vec<SyntaxElement>,
cx: LowerCtx<'_>,
glue_matched_args: bool,
) -> Vec<SyntaxElement> {
let mut out = Vec::new();
for element in elements {
match &element {
SyntaxElement::Node(node)
if node.kind() == SyntaxKind::COMMAND && command_is_inline_prose(node, cx) =>
{
expand_inline_prose(node, cx, glue_matched_args, &mut out);
}
_ => out.push(element),
}
}
out
}
fn expand_inline_prose(
node: &SyntaxNode,
cx: LowerCtx<'_>,
glue_matched_args: bool,
out: &mut Vec<SyntaxElement>,
) {
let Some(sig) = cx.signatures.command_at(node) else {
out.push(SyntaxElement::Node(node.clone()));
return;
};
let mut slot = 0usize;
let mut pending_trivia = Vec::new();
for child in node.children_with_tokens() {
if is_collapsible_trivia_element(&child) {
pending_trivia.push(child);
continue;
}
match child {
SyntaxElement::Node(group)
if matches!(group.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL) =>
{
let is_bracket = group.kind() == SyntaxKind::OPTIONAL;
let kind = if is_bracket {
ArgKind::Bracket
} else {
ArgKind::Brace
};
let spec = match_arg_slot(&sig.args, &mut slot, kind);
let follows_comment = out.last().is_some_and(
|element| matches!(element, SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT),
);
if spec.is_none() || follows_comment || !glue_matched_args {
out.append(&mut pending_trivia);
} else {
pending_trivia.clear();
}
let prose = spec.is_some_and(|spec| spec.content == ContentKind::Prose);
if prose {
let (open, close) = if is_bracket {
(SyntaxKind::L_BRACKET, SyntaxKind::R_BRACKET)
} else {
(SyntaxKind::L_BRACE, SyntaxKind::R_BRACE)
};
splice_prose_group(&group, open, close, cx, glue_matched_args, out);
} else {
out.push(SyntaxElement::Node(group));
}
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::VERB => {
out.append(&mut pending_trivia);
if token.text().starts_with('{') {
match_verbatim_arg_slot(&sig.args, &mut slot);
}
out.push(SyntaxElement::Token(token));
}
other => {
out.append(&mut pending_trivia);
out.push(other);
}
}
}
out.append(&mut pending_trivia);
}
fn splice_prose_group(
group: &SyntaxNode,
open_kind: SyntaxKind,
close_kind: SyntaxKind,
cx: LowerCtx<'_>,
glue_matched_args: bool,
out: &mut Vec<SyntaxElement>,
) {
let mut open: Option<SyntaxElement> = None;
let mut close: Option<SyntaxElement> = None;
let mut body: Vec<SyntaxElement> = Vec::new();
for element in group.children_with_tokens() {
match &element {
SyntaxElement::Token(t) if t.kind() == open_kind && open.is_none() => {
open = Some(element);
}
SyntaxElement::Token(t) if t.kind() == close_kind => {
close = Some(element);
}
_ => body.push(element),
}
}
while body.first().is_some_and(is_collapsible_trivia_element) {
body.remove(0);
}
while body.last().is_some_and(is_collapsible_trivia_element) {
body.pop();
}
if let Some(open) = open {
out.push(open);
}
out.extend(flatten_inline_prose(body, cx, glue_matched_args));
if let Some(close) = close {
out.push(close);
}
}
fn is_collapsible_trivia_element(element: &SyntaxElement) -> bool {
matches!(element, SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()))
}
fn inline_token_list_atoms(node: &SyntaxNode, cx: LowerCtx<'_>) -> Option<Vec<Ir>> {
let sig = cx.signatures.command_at(node)?;
let mut slot = 0usize;
let mut found = false;
let mut atoms: Vec<Vec<Ir>> = vec![Vec::new()];
for element in alignment_cell_elements(node.children_with_tokens(), cx) {
match element {
SyntaxElement::Node(group)
if matches!(group.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL) =>
{
let is_bracket = group.kind() == SyntaxKind::OPTIONAL;
let (open_kind, close_kind, kind) = if is_bracket {
(
SyntaxKind::L_BRACKET,
SyntaxKind::R_BRACKET,
ArgKind::Bracket,
)
} else {
(SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, ArgKind::Brace)
};
let spec = match_arg_slot(&sig.args, &mut slot, kind);
if spec.is_some_and(|spec| spec.content == ContentKind::TokenList) {
let GroupSegments {
open,
mut parts,
close,
splits,
} = segment_delimited_body(&group, open_kind, close_kind, cx, true)?;
if splits == 0 {
return None;
}
let _ = peel_padding(&mut parts, Edge::Leading);
let _ = peel_padding(&mut parts, Edge::Trailing);
atoms.last_mut().unwrap().push(open);
for part in parts {
if is_segment_separator(&part) {
atoms.push(Vec::new());
} else {
atoms.last_mut().unwrap().push(part);
}
}
atoms.last_mut().unwrap().push(close);
found = true;
} else {
atoms.last_mut().unwrap().push(lower_node(&group, cx));
}
}
SyntaxElement::Token(token) if token.kind() == SyntaxKind::VERB => {
if token.text().starts_with('{') {
match_verbatim_arg_slot(&sig.args, &mut slot);
}
atoms
.last_mut()
.unwrap()
.push(lower_loose_token(&token, cx));
}
SyntaxElement::Node(child) => atoms.last_mut().unwrap().push(lower_node(&child, cx)),
SyntaxElement::Token(token) => {
atoms
.last_mut()
.unwrap()
.push(lower_loose_token(&token, cx));
}
}
}
found.then(|| atoms.into_iter().map(Ir::concat).collect())
}
fn lower_command(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
lower_command_with_math_spacing(node, cx, MathSpacing::Normal)
}
fn lower_command_with_math_spacing(
node: &SyntaxNode,
cx: LowerCtx<'_>,
math_spacing: MathSpacing,
) -> Ir {
let Some(sig) = cx.signatures.command_at(node) else {
return Ir::concat(lower_element_stream(node.children_with_tokens(), cx));
};
let math_only = sig
.args
.iter()
.any(|spec| spec.domain == ArgumentDomain::Math);
let mut out: Vec<Ir> = Vec::new();
let mut slot = 0usize;
let mut iter = alignment_cell_elements(node.children_with_tokens(), cx)
.into_iter()
.peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Node(child)
if matches!(child.kind(), SyntaxKind::GROUP | SyntaxKind::OPTIONAL) =>
{
let is_bracket = child.kind() == SyntaxKind::OPTIONAL;
let (open, close) = if is_bracket {
(SyntaxKind::L_BRACKET, SyntaxKind::R_BRACKET)
} else {
(SyntaxKind::L_BRACE, SyntaxKind::R_BRACE)
};
let kind = if is_bracket {
ArgKind::Bracket
} else {
ArgKind::Brace
};
let spec = match_arg_slot(&sig.args, &mut slot, kind);
if math_only {
if spec.is_some_and(|spec| spec.domain == ArgumentDomain::Math) {
out.push(lower_math_argument_group(&child, cx, math_spacing));
} else {
out.push(Ir::verbatim(child.text().to_string()));
}
continue;
}
match spec.map(|s| s.content) {
Some(ContentKind::Identifier) => {
out.push(lower_identifier_group(&child));
}
Some(ContentKind::Algorithm2e) => {
out.push(lower_prose_group_kind(
&child,
open,
close,
cx,
ReflowKind::Algorithm2e,
));
}
Some(ContentKind::Prose) if sig.inline => {
out.push(lower_inline_prose_group(&child, open, close, cx));
}
Some(ContentKind::Prose) => {
out.push(lower_prose_group(&child, open, close, cx));
}
Some(ContentKind::TokenList) => {
out.push(
lower_token_list_group(&child, open, close, cx)
.unwrap_or_else(|| lower_node(&child, cx)),
);
}
Some(ContentKind::Keyval) => {
out.push(
lower_segmented_group(&child, open, close, cx, true)
.unwrap_or_else(|| lower_node(&child, cx)),
);
}
_ => out.push(lower_node(&child, cx)),
}
}
SyntaxElement::Node(child) if math_only => {
out.push(Ir::verbatim(child.text().to_string()))
}
SyntaxElement::Node(child) => out.push(lower_node(&child, cx)),
SyntaxElement::Token(token) if token.kind() == SyntaxKind::VERB => {
if token.text().starts_with('{') {
match_verbatim_arg_slot(&sig.args, &mut slot);
}
out.push(lower_loose_token(&token, cx));
}
SyntaxElement::Token(token) if math_only => out.push(Ir::verbatim(token.text())),
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
out.push(classify_trivia(
consume_gap_widened(&token, &mut iter),
cx.in_alignment_cell,
));
}
SyntaxElement::Token(token) => out.push(lower_loose_token(&token, cx)),
}
}
Ir::concat(out)
}
fn lower_inline_prose_group(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
) -> Ir {
let mut elements = Vec::new();
splice_prose_group(node, open, close, cx, false, &mut elements);
reflow_elements(elements.into_iter(), cx, ReflowKind::ProseArg)
}
fn lower_prose_group(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
) -> Ir {
lower_prose_group_kind(node, open, close, cx, ReflowKind::ProseArg)
}
fn lower_prose_group_kind(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
kind: ReflowKind,
) -> Ir {
let mut open_ir = Ir::Nil;
let mut close_ir = Ir::Nil;
let mut body_elements: Vec<SyntaxElement> = Vec::new();
for element in alignment_cell_elements(node.children_with_tokens(), cx) {
match &element {
SyntaxElement::Token(t) if t.kind() == open && matches!(open_ir, Ir::Nil) => {
open_ir = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == close => {
close_ir = Ir::verbatim(t.text());
}
_ => body_elements.push(element),
}
}
let has_leading_comment = body_elements
.first()
.and_then(SyntaxElement::as_token)
.is_some_and(|t| t.kind() == SyntaxKind::COMMENT);
let open_ir = if has_leading_comment {
let comment = body_elements.remove(0);
Ir::concat([open_ir, Ir::verbatim(comment.as_token().unwrap().text())])
} else {
open_ir
};
let has_trailing_comment = body_ends_with_comment(node, close);
let body = reflow_elements(body_elements.into_iter(), cx, kind);
if matches!(body, Ir::Nil) {
if has_leading_comment {
Ir::concat([open_ir, Ir::hard_line(), close_ir])
} else {
Ir::concat([open_ir, close_ir])
}
} else {
let brk: fn() -> Ir =
if has_leading_comment || has_trailing_comment || kind == ReflowKind::Algorithm2e {
Ir::hard_line
} else {
Ir::soft_line
};
Ir::group(Ir::concat([
open_ir,
Ir::indent(Ir::concat([brk(), body])),
brk(),
close_ir,
]))
}
}
fn body_ends_with_comment(node: &SyntaxNode, close: SyntaxKind) -> bool {
let mut token = node.last_token();
while let Some(t) = token {
if !node.text_range().contains_range(t.text_range()) {
return false; }
match t.kind() {
SyntaxKind::COMMENT => return true,
k if k == close || is_collapsible_trivia(k) => token = t.prev_token(),
_ => return false,
}
}
false
}
fn lower_token_list_group(
node: &SyntaxNode,
open_kind: SyntaxKind,
close_kind: SyntaxKind,
cx: LowerCtx<'_>,
) -> Option<Ir> {
if node
.children_with_tokens()
.any(|element| matches!(element.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD))
{
return None;
}
let GroupSegments {
open,
mut parts,
close,
..
} = segment_delimited_body(node, open_kind, close_kind, cx, true)?;
let _ = peel_padding(&mut parts, Edge::Leading);
let _ = peel_padding(&mut parts, Edge::Trailing);
Some(Ir::concat([
open,
Ir::concat(parts.into_iter().filter(|part| !is_segment_separator(part))),
close,
]))
}
fn lower_identifier_group(node: &SyntaxNode) -> Ir {
let preserve = || Ir::verbatim(node.text().to_string());
let mut parts = Vec::new();
let mut iter = node.children_with_tokens().peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(token) if is_collapsible_trivia(token.kind()) => {
let gap = consume_gap(&token, &mut iter);
if gap == Gap::Blank {
return preserve();
}
parts.push(Ir::verbatim(gap.flat()));
}
SyntaxElement::Token(token)
if matches!(
token.kind(),
SyntaxKind::COMMENT | SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD
) =>
{
return preserve();
}
SyntaxElement::Token(token) => parts.push(Ir::verbatim(token.text())),
SyntaxElement::Node(_) => return preserve(),
}
}
Ir::concat(parts)
}
fn collapse_arg_group(
node: &SyntaxNode,
open: SyntaxKind,
close: SyntaxKind,
cx: LowerCtx<'_>,
) -> Option<Ir> {
let mut open_ir = Ir::Nil;
let mut close_ir = Ir::Nil;
let mut body: Vec<Ir> = Vec::new();
let mut iter = node.children_with_tokens().peekable();
while let Some(element) = iter.next() {
match element {
SyntaxElement::Token(t) if t.kind() == open && matches!(open_ir, Ir::Nil) => {
open_ir = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if t.kind() == close => {
close_ir = Ir::verbatim(t.text());
}
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
let gap = consume_gap(&t, &mut iter);
if gap == Gap::Blank {
return None; }
body.push(Ir::verbatim(gap.flat()));
}
SyntaxElement::Token(t)
if matches!(
t.kind(),
SyntaxKind::COMMENT | SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD
) =>
{
return None;
}
SyntaxElement::Token(t) => body.push(Ir::verbatim(t.text())),
SyntaxElement::Node(child) => {
let ir = lower_node(&child, cx);
if ir.contains_forced_break() {
return None; }
body.push(ir);
}
}
}
let body = trim_trailing_break(trim_leading_break(Ir::concat(body)));
Some(Ir::concat([open_ir, body, close_ir]))
}
fn strip_virtual_dtx_framing(
elements: impl IntoIterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
) -> Vec<SyntaxElement> {
if !cx.in_dtx_doc_region {
return elements.into_iter().collect();
}
let mut stripped = Vec::new();
let mut after_margin = false;
for element in elements {
match &element {
SyntaxElement::Token(token) if token.kind() == SyntaxKind::DOC_MARGIN => {
after_margin = true;
}
SyntaxElement::Token(token)
if after_margin && token.kind() == SyntaxKind::WHITESPACE => {}
_ => {
after_margin = false;
stripped.push(element);
}
}
}
stripped
}
fn alignment_cell_elements(
elements: impl IntoIterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
) -> Vec<SyntaxElement> {
if cx.in_alignment_cell {
strip_virtual_dtx_framing(elements, cx)
} else {
elements.into_iter().collect()
}
}
fn lower_math(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
Ir::concat(
strip_virtual_dtx_framing(node.children_with_tokens(), cx)
.into_iter()
.map(|el| match el {
SyntaxElement::Node(n) if n.kind() == SyntaxKind::MATH => lower_math_body(&n, cx),
SyntaxElement::Node(n) => lower_node(&n, cx),
SyntaxElement::Token(t) => Ir::verbatim(t.text()),
}),
)
}
fn lower_display_math(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
let mut open = String::new();
let mut close = String::new();
let mut body = Ir::Nil;
let mut body_empty = true;
let mut seen_body = false;
let mut open_has_comment = false;
for element in strip_virtual_dtx_framing(node.children_with_tokens(), cx) {
match element {
SyntaxElement::Node(n) if n.kind() == SyntaxKind::MATH => {
let lifted = leading_inline_comment(&[SyntaxElement::Node(n.clone())]);
if let Some(comment) = &lifted {
open.push_str(comment.text());
open_has_comment = true;
}
let elements: Vec<SyntaxElement> = n
.children_with_tokens()
.filter(|e| !is_lifted_comment(e, lifted.as_ref()))
.collect();
let body_cx = cx.absorbing_trailing_control_newline(&elements);
body_empty = elements.iter().all(|e| {
e.as_token()
.is_some_and(|t| is_collapsible_trivia(t.kind()))
});
body = trim_trailing_break(lower_display_formula_elements(&elements, body_cx));
seen_body = true;
}
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {}
SyntaxElement::Token(t) if seen_body => close.push_str(t.text()),
SyntaxElement::Token(t) => open.push_str(t.text()),
SyntaxElement::Node(n) => {
body = lower_node(&n, cx);
body_empty = false;
seen_body = true;
}
}
}
if body_empty {
if open_has_comment {
Ir::concat([Ir::verbatim(open), Ir::hard_line(), Ir::verbatim(close)])
} else {
Ir::concat([Ir::verbatim(open), Ir::verbatim(close)])
}
} else {
Ir::concat([
Ir::verbatim(open),
Ir::indent(Ir::concat([Ir::hard_line(), body])),
Ir::hard_line(),
Ir::verbatim(close),
])
}
}
fn lower_math_body(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
lower_math_seq(node.children_with_tokens(), cx, MathSpacing::Normal, false)
}
fn lower_display_formula_elements(elements: &[SyntaxElement], cx: LowerCtx<'_>) -> Ir {
if let Some((label, rest)) = split_leading_label(elements) {
return Ir::concat([
lower_math_element(label, cx, MathSpacing::Normal),
Ir::hard_line(),
lower_display_formula_elements(rest, cx),
]);
}
match cx.math_wrap {
MathWrap::Auto | MathWrap::Break => lower_display_math_body(elements, cx),
MathWrap::SingleLine => {
lower_math_seq(elements.iter().cloned(), cx, MathSpacing::Normal, false)
}
MathWrap::Preserve => {
lower_math_seq(elements.iter().cloned(), cx, MathSpacing::Normal, true)
}
}
}
fn split_leading_label(elements: &[SyntaxElement]) -> Option<(SyntaxElement, &[SyntaxElement])> {
let idx = elements
.iter()
.position(|e| !is_collapsible_trivia_element(e))?;
let node = elements[idx].as_node()?;
if node.kind() != SyntaxKind::COMMAND
|| crate::ast::command_name(node).as_deref() != Some("label")
{
return None;
}
let rest = &elements[idx + 1..];
if rest.iter().all(is_collapsible_trivia_element) {
return None;
}
Some((elements[idx].clone(), rest))
}
#[derive(Clone, Copy, PartialEq)]
enum MathRole {
Operand,
Binary,
Relation,
PostfixLeftLimit,
}
impl MathRole {
fn is_operand_like(self) -> bool {
matches!(self, Self::Operand | Self::PostfixLeftLimit)
}
}
#[derive(Clone, Copy, PartialEq)]
enum MathSpacing {
Normal,
Script,
}
struct MathPiece {
ir: Ir,
role: MathRole,
block_break_before: bool,
break_before: bool,
colon_relation_prefix: bool,
spaced_slash: bool,
slash: bool,
space_before: bool,
sized_delimiter: Option<DelimiterRole>,
bracket_delta: i32,
}
struct MathSurfaceAtom {
sized_delimiter: Option<DelimiterRole>,
ir: Ir,
multiline_block: bool,
block_suffix: bool,
class: MathClass,
break_kind: MathBreakKind,
delimiter: Option<DelimiterRole>,
colon_relation_prefix: bool,
starts_equals_relation: bool,
spaced_slash: bool,
slash: bool,
control_word_operator: bool,
starts_control_word_letter: bool,
ends_control_word: bool,
postfix_left_limit: bool,
}
fn lower_sized_math_atoms(
element: SyntaxElement,
iter: &mut impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
spacing: MathSpacing,
) -> Vec<MathSurfaceAtom> {
let name = match &element {
SyntaxElement::Node(node) if node.kind() == SyntaxKind::COMMAND => {
let mut children = node.children_with_tokens();
match (children.next(), children.next()) {
(Some(SyntaxElement::Token(token)), None) => token.text().to_owned(),
_ => return lower_math_atoms(element, cx, spacing),
}
}
_ => return lower_math_atoms(element, cx, spacing),
};
let sized = ["big", "Big", "bigg", "Bigg"].iter().any(|prefix| {
name.strip_prefix('\\')
.and_then(|name| name.strip_prefix(prefix))
.is_some_and(|suffix| matches!(suffix, "" | "l" | "r" | "m"))
});
if !sized {
return lower_math_atoms(element, cx, spacing);
}
let mut next = element.next_sibling_or_token();
let mut skip = 0;
while next
.as_ref()
.is_some_and(|el| is_collapsible_trivia(el.kind()))
{
next = next.and_then(|element| element.next_sibling_or_token());
skip += 1;
}
let Some(delimiter) = next else {
return lower_math_atoms(element, cx, spacing);
};
let role = math_atoms(&delimiter)
.next()
.and_then(|atom| atom.delimiter);
let Some(mut role) = role else {
return lower_math_atoms(element, cx, spacing);
};
if name.ends_with('l') {
role = DelimiterRole::Open;
} else if name.ends_with('r') {
role = DelimiterRole::Close;
} else if name.ends_with('m') {
role = DelimiterRole::Fence;
}
for _ in 0..skip {
iter.next();
}
let Some(delimiter) = iter.next() else {
return lower_math_atoms(element, cx, spacing);
};
let mut atoms = lower_math_atoms(delimiter, cx, spacing);
if let Some(first) = atoms.first_mut() {
let middle = name.ends_with('m');
first.ir = Ir::concat([Ir::verbatim(name), first.ir.clone()]);
first.starts_control_word_letter = false;
first.sized_delimiter = Some(role);
first.delimiter = Some(role);
first.control_word_operator = middle;
first.class = match role {
DelimiterRole::Open => MathClass::Open,
DelimiterRole::Close => MathClass::Close,
DelimiterRole::Fence if middle => MathClass::Rel,
DelimiterRole::Fence => MathClass::Fence,
};
}
atoms
}
fn sized_delimiter_space(previous: Option<DelimiterRole>, current: Option<DelimiterRole>) -> bool {
(previous == Some(DelimiterRole::Open) || current == Some(DelimiterRole::Close))
&& !(previous == Some(DelimiterRole::Open) && current == Some(DelimiterRole::Close))
}
#[derive(Default)]
struct MathBlockBoundaries {
seen_block: bool,
after_block: bool,
line_has_expression: bool,
}
impl MathBlockBoundaries {
fn before(&mut self, atom: &MathSurfaceAtom) -> bool {
let should_break = self.after_block && !atom.block_suffix
|| atom.multiline_block && self.seen_block && self.line_has_expression;
if should_break {
self.line_has_expression = false;
}
if atom.multiline_block {
self.seen_block = true;
self.after_block = true;
self.line_has_expression = false;
} else if !atom.block_suffix {
self.after_block = false;
self.line_has_expression |= !matches!(atom.class, MathClass::Bin | MathClass::Rel);
}
should_break
}
}
#[derive(Clone, Copy, PartialEq)]
enum MathBreakKind {
Class,
Additive,
Multiplicative,
Conditional,
}
fn math_break_kind(element: &SyntaxElement) -> MathBreakKind {
let SyntaxElement::Node(node) = element else {
return match element.as_token().map(|token| token.text()) {
Some("+" | "-") => MathBreakKind::Additive,
_ => MathBreakKind::Class,
};
};
if node.kind() == SyntaxKind::SCRIPTED {
return node
.children_with_tokens()
.find(|element| {
!matches!(
element.kind(),
SyntaxKind::WHITESPACE
| SyntaxKind::NEWLINE
| SyntaxKind::SUBSCRIPT
| SyntaxKind::SUPERSCRIPT
)
})
.as_ref()
.map_or(MathBreakKind::Class, math_break_kind);
}
if node.kind() != SyntaxKind::COMMAND {
return MathBreakKind::Class;
}
match crate::ast::command_name(node).as_deref() {
Some("pm" | "mp") => MathBreakKind::Additive,
Some("cdot") => MathBreakKind::Multiplicative,
Some("mid") => MathBreakKind::Conditional,
_ => MathBreakKind::Class,
}
}
fn lower_math_atoms(
el: SyntaxElement,
cx: LowerCtx<'_>,
spacing: MathSpacing,
) -> Vec<MathSurfaceAtom> {
let atoms: Vec<_> = math_atoms(&el).collect();
let break_kind = math_break_kind(&el);
let SyntaxElement::Token(token) = &el else {
let starts_control_word_letter = element_starts_control_word_letter(&el);
let ends_control_word = element_ends_control_word(&el);
let starts_with_equals = element_starts_with_token_text(&el, "=");
let atom = atoms
.into_iter()
.next()
.expect("a structural math element has one semantic atom");
let control_word_operator =
ends_control_word && matches!(atom.class, MathClass::Bin | MathClass::Rel);
let block_suffix = atom.class == MathClass::Punct
|| atom.delimiter == Some(DelimiterRole::Close)
|| el.kind() == SyntaxKind::LINE_BREAK;
let block_shape = el.kind() == SyntaxKind::ENVIRONMENT
|| matches!(
el.kind(),
SyntaxKind::LEFT_RIGHT | SyntaxKind::GROUP | SyntaxKind::SCRIPTED
) && el.as_node().is_some_and(|node| {
node.descendants()
.any(|child| child.kind() == SyntaxKind::ENVIRONMENT)
});
let ir = lower_math_element(el, cx, spacing);
let multiline_block = block_shape && ir.contains_forced_break();
return vec![MathSurfaceAtom {
sized_delimiter: None,
ir,
multiline_block,
block_suffix,
class: atom.class,
break_kind,
delimiter: atom.delimiter,
colon_relation_prefix: false,
starts_equals_relation: atom.class == MathClass::Rel && starts_with_equals,
spaced_slash: false,
slash: false,
control_word_operator,
starts_control_word_letter,
ends_control_word,
postfix_left_limit: false,
}];
};
if token.kind() != SyntaxKind::WORD {
let starts_control_word_letter = token
.text()
.chars()
.next()
.is_some_and(is_control_word_letter);
let ends_control_word = token.kind() == SyntaxKind::CONTROL_WORD;
let atom = atoms
.into_iter()
.next()
.expect("a math token has one semantic atom");
let control_word_operator =
ends_control_word && matches!(atom.class, MathClass::Bin | MathClass::Rel);
return vec![MathSurfaceAtom {
sized_delimiter: None,
ir: lower_math_element(el, cx, spacing),
multiline_block: false,
block_suffix: atom.class == MathClass::Punct
|| atom.delimiter == Some(DelimiterRole::Close),
class: atom.class,
break_kind,
delimiter: atom.delimiter,
colon_relation_prefix: false,
starts_equals_relation: false,
spaced_slash: false,
slash: false,
control_word_operator,
starts_control_word_letter,
ends_control_word,
postfix_left_limit: false,
}];
}
let token_start = token.text_range().start();
let mut surface: Vec<MathSurfaceAtom> = Vec::with_capacity(atoms.len());
for atom in atoms {
let start = usize::from(atom.range.start() - token_start);
let end = usize::from(atom.range.end() - token_start);
let text = &token.text()[start..end];
if let Some(previous) = surface.last_mut() {
let extends_colon_prefix =
previous.colon_relation_prefix && atom.class == MathClass::Punct && text == ":";
let completes_colon_relation =
previous.colon_relation_prefix && atom.class == MathClass::Rel && text == "=";
if previous.class == MathClass::Rel && atom.class == MathClass::Rel
|| extends_colon_prefix
|| completes_colon_relation
{
previous.ir = Ir::concat([previous.ir.clone(), Ir::verbatim(text)]);
if completes_colon_relation {
previous.class = MathClass::Rel;
previous.colon_relation_prefix = false;
}
continue;
}
}
surface.push(MathSurfaceAtom {
sized_delimiter: None,
ir: Ir::verbatim(text),
multiline_block: false,
block_suffix: atom.class == MathClass::Punct
|| atom.delimiter == Some(DelimiterRole::Close)
|| text == ".",
class: atom.class,
break_kind: match text {
"+" | "-" => MathBreakKind::Additive,
_ => MathBreakKind::Class,
},
delimiter: atom.delimiter,
colon_relation_prefix: atom.class == MathClass::Punct && text == ":",
starts_equals_relation: false,
spaced_slash: atom.class == MathClass::Ord
&& text == "/"
&& (start == 0
&& token
.prev_token()
.is_some_and(|token| is_collapsible_trivia(token.kind()))
|| end == token.text().len()
&& token
.next_token()
.is_some_and(|token| is_collapsible_trivia(token.kind()))),
slash: atom.class == MathClass::Ord && text == "/",
control_word_operator: false,
starts_control_word_letter: text.chars().next().is_some_and(is_control_word_letter),
ends_control_word: false,
postfix_left_limit: text == "-",
});
}
let following_token_closes = || {
let mut next = token.next_token();
while next
.as_ref()
.is_some_and(|token| is_collapsible_trivia(token.kind()))
{
next = next.and_then(|token| token.next_token());
}
next.and_then(|token| math_atoms(&SyntaxElement::Token(token)).next())
.is_some_and(|atom| atom.delimiter == Some(DelimiterRole::Close))
};
for index in 0..surface.len() {
let followed_by_closer = surface
.get(index + 1)
.is_some_and(|next| next.delimiter == Some(DelimiterRole::Close))
|| index + 1 == surface.len() && following_token_closes();
surface[index].postfix_left_limit &= followed_by_closer;
}
for index in 0..surface.len() {
if !surface[index].slash || surface[index].spaced_slash {
continue;
}
let next_operator = surface.get(index + 1).is_some_and(|next| {
spacing == MathSpacing::Normal && matches!(next.class, MathClass::Bin | MathClass::Rel)
}) || index + 1 == surface.len()
&& token.next_token().is_some_and(|next| {
let class = math_atoms(&SyntaxElement::Token(next.clone()))
.next()
.map(|atom| atom.class);
class.is_some_and(|class| {
matches!(class, MathClass::Bin | MathClass::Rel)
&& (spacing == MathSpacing::Normal
|| next.kind() == SyntaxKind::CONTROL_WORD)
})
});
surface[index].spaced_slash = next_operator;
}
surface
}
fn is_control_word_letter(character: char) -> bool {
character.is_alphabetic()
}
fn element_starts_control_word_letter(element: &SyntaxElement) -> bool {
let first = match element {
SyntaxElement::Node(node) => node
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| !is_collapsible_trivia(token.kind())),
SyntaxElement::Token(token) => Some(token.clone()),
};
first
.as_ref()
.and_then(|token| token.text().chars().next())
.is_some_and(is_control_word_letter)
}
fn element_starts_with_token_text(element: &SyntaxElement, expected: &str) -> bool {
match element {
SyntaxElement::Node(node) => node
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| !is_collapsible_trivia(token.kind())),
SyntaxElement::Token(token) => Some(token.clone()),
}
.is_some_and(|token| token.text() == expected)
}
fn element_ends_control_word(element: &SyntaxElement) -> bool {
let last = match element {
SyntaxElement::Node(node) => node
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter(|token| !is_collapsible_trivia(token.kind()))
.last(),
SyntaxElement::Token(token) => Some(token.clone()),
};
last.is_some_and(|token| token.kind() == SyntaxKind::CONTROL_WORD)
}
fn math_atom_role(
class: MathClass,
prev_class: MathClass,
prev_opener: bool,
postfix_left_limit: bool,
) -> MathRole {
if postfix_left_limit {
return MathRole::PostfixLeftLimit;
}
let raw = match class {
MathClass::Bin => MathRole::Binary,
MathClass::Rel => MathRole::Relation,
_ => MathRole::Operand,
};
if raw == MathRole::Binary
&& (matches!(
prev_class,
MathClass::Op | MathClass::Bin | MathClass::Rel | MathClass::Punct
) || prev_opener)
{
MathRole::Operand
} else {
raw
}
}
fn collect_math_pieces(elements: &[SyntaxElement], cx: LowerCtx<'_>) -> Option<Vec<MathPiece>> {
let mut pieces: Vec<MathPiece> = Vec::new();
let mut blocks = MathBlockBoundaries::default();
let mut prev_class = MathClass::Rel;
let mut prev_opener = false;
let mut bracket_depth = 0_i32;
let mut conditional_at_top_level = false;
let mut pending_space = false;
let mut iter = strip_virtual_dtx_framing(elements.iter().cloned(), cx)
.into_iter()
.peekable();
while let Some(el) = iter.next() {
match el {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
consume_gap(&t, &mut iter);
if !pieces.is_empty() {
pending_space = true;
}
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => return None,
SyntaxElement::Node(n) if n.kind() == SyntaxKind::LINE_BREAK => return None,
other => {
for atom in lower_sized_math_atoms(other, &mut iter, cx, MathSpacing::Normal) {
let role = math_atom_role(
atom.class,
prev_class,
prev_opener,
atom.postfix_left_limit,
);
let completes_colon_relation = !pending_space
&& pieces
.last()
.is_some_and(|piece| piece.colon_relation_prefix)
&& atom.starts_equals_relation;
if completes_colon_relation {
let previous = pieces.last_mut().expect("checked above");
previous.ir = Ir::concat([previous.ir.clone(), atom.ir]);
previous.role = MathRole::Relation;
previous.colon_relation_prefix = false;
previous.bracket_delta += match atom.delimiter {
Some(DelimiterRole::Open) => 1,
Some(DelimiterRole::Close) => -1,
Some(DelimiterRole::Fence) | None => 0,
};
prev_class = MathClass::Rel;
prev_opener = atom.delimiter == Some(DelimiterRole::Open);
continue;
}
prev_class = atom.class;
prev_opener = atom.delimiter == Some(DelimiterRole::Open);
let bracket_delta = match atom.delimiter {
Some(DelimiterRole::Open) => 1,
Some(DelimiterRole::Close) => -1,
Some(DelimiterRole::Fence) | None => 0,
};
let block_break_before = blocks.before(&atom);
pieces.push(MathPiece {
ir: atom.ir,
role,
block_break_before,
break_before: !matches!(
atom.break_kind,
MathBreakKind::Multiplicative | MathBreakKind::Conditional
) && !(role == MathRole::Relation
&& conditional_at_top_level),
colon_relation_prefix: atom.colon_relation_prefix,
spaced_slash: atom.spaced_slash,
slash: atom.slash,
space_before: pending_space,
sized_delimiter: atom.sized_delimiter,
bracket_delta,
});
if atom.break_kind == MathBreakKind::Conditional && bracket_depth == 0 {
conditional_at_top_level = true;
}
bracket_depth += bracket_delta;
pending_space = false;
}
}
}
}
for index in 0..pieces.len() {
if pieces[index].slash
&& (index > 0 && !pieces[index - 1].role.is_operand_like()
|| pieces
.get(index + 1)
.is_some_and(|next| !next.role.is_operand_like()))
{
pieces[index].spaced_slash = true;
}
}
(pieces.len() >= 2).then_some(pieces)
}
fn lower_display_math_body(elements: &[SyntaxElement], cx: LowerCtx<'_>) -> Ir {
let Some(pieces) = collect_math_pieces(elements, cx) else {
return lower_math_seq_with_blocks(
elements.iter().cloned(),
cx,
MathSpacing::Normal,
false,
true,
);
};
let mut parts = Vec::new();
let mut start = 0;
let mut depth = 0;
for end in 1..=pieces.len() {
if end == pieces.len() || pieces[end].block_break_before {
if start > 0 {
parts.push(Ir::hard_line());
}
parts.push(lower_math_piece_chain(&pieces[start..end], depth));
depth += pieces[start..end]
.iter()
.map(|piece| piece.bracket_delta)
.sum::<i32>();
start = end;
}
}
Ir::concat(parts)
}
fn lower_math_piece_chain(pieces: &[MathPiece], initial_depth: i32) -> Ir {
let flat_width = |ir: &Ir| {
Printer::new(FormatStyle::default())
.print_flat(ir)
.chars()
.count()
};
let depth_before: Vec<i32> = {
let mut acc = initial_depth;
let mut v = Vec::with_capacity(pieces.len());
for p in pieces {
v.push(acc);
acc += p.bracket_delta;
}
v
};
let space_sep = |k: usize| -> Ir {
if sized_delimiter_space(pieces[k - 1].sized_delimiter, pieces[k].sized_delimiter)
|| pieces[k].spaced_slash
|| pieces[k - 1].spaced_slash
{
Ir::verbatim(" ")
} else if pieces[k].role == MathRole::PostfixLeftLimit
|| pieces[k - 1].role == MathRole::PostfixLeftLimit
{
Ir::Nil
} else if pieces[k].role != MathRole::Operand
|| pieces[k - 1].role != MathRole::Operand
|| pieces[k].space_before
{
Ir::text(" ")
} else {
Ir::Nil
}
};
let breakable = |k: usize| -> bool {
pieces[k].break_before
&& pieces[k].role == MathRole::Binary
&& pieces[k - 1].role == MathRole::Operand
&& depth_before[k] == 0
};
let is_anchor = |k: usize| {
pieces[k].break_before && pieces[k].role == MathRole::Relation && depth_before[k] == 0
};
let Some(anchor) = (0..pieces.len()).find(|&k| is_anchor(k)) else {
let mut parts: Vec<Ir> = Vec::with_capacity(pieces.len() * 2);
for (i, piece) in pieces.iter().enumerate() {
if i > 0 {
parts.push(if breakable(i) {
Ir::line()
} else {
space_sep(i)
});
}
parts.push(piece.ir.clone());
}
return Ir::group(Ir::concat(parts));
};
let mut lhs: Vec<Ir> = Vec::new();
for (i, piece) in pieces[..anchor].iter().enumerate() {
if i > 0 {
lhs.push(space_sep(i));
}
lhs.push(piece.ir.clone());
}
let lhs_multiline = pieces[..anchor]
.iter()
.any(|p| p.ir.contains_forced_break());
let rel_col = if anchor == 0 || lhs_multiline {
0
} else {
flat_width(&Ir::concat(lhs.clone())) + 1
};
let relation_width = (anchor..pieces.len())
.filter(|&k| is_anchor(k))
.map(|k| flat_width(&pieces[k].ir))
.max()
.expect("the first relation anchors the chain");
let first_rhs = anchor + 1;
let pad_first_relation = relation_width > flat_width(&pieces[anchor].ir)
&& first_rhs < pieces.len()
&& !is_anchor(first_rhs);
let build_relation_layout = |relation_indent: usize, break_before_first: bool| {
let mut parts = lhs.clone();
let mut i = anchor;
let mut first_segment = true;
while i < pieces.len() {
if first_segment {
if lhs_multiline {
parts.push(Ir::hard_line());
} else if break_before_first {
parts.push(Ir::line());
} else if anchor > 0 {
parts.push(space_sep(anchor));
}
} else {
parts.push(Ir::line());
}
parts.push(pieces[i].ir.clone());
let relw = flat_width(&pieces[i].ir);
let start = i + 1;
let mut j = start;
while j < pieces.len() && !is_anchor(j) {
j += 1;
}
if start < j && relw < relation_width {
parts.push(Ir::if_break(
Ir::Nil,
Ir::text(" ".repeat(relation_width - relw)),
));
}
let mut rhs: Vec<Ir> = Vec::with_capacity((j - start) * 2);
for (offset, piece) in pieces[start..j].iter().enumerate() {
let k = start + offset;
rhs.push(if breakable(k) {
Ir::line()
} else {
space_sep(k)
});
rhs.push(piece.ir.clone());
}
parts.push(Ir::group(Ir::align(relation_width + 1, Ir::concat(rhs))));
first_segment = false;
i = j;
}
Ir::align(relation_indent, Ir::concat(parts))
};
let body = if rel_col == 0 {
build_relation_layout(0, lhs_multiline)
} else {
Ir::bounded_align(
build_relation_layout(rel_col, false),
build_relation_layout(0, true),
pad_first_relation,
)
};
Ir::group(body)
}
fn lower_math_seq(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
spacing: MathSpacing,
preserve_newlines: bool,
) -> Ir {
lower_math_seq_with_blocks(elements, cx, spacing, preserve_newlines, false)
}
fn lower_math_seq_with_blocks(
elements: impl Iterator<Item = SyntaxElement>,
cx: LowerCtx<'_>,
spacing: MathSpacing,
preserve_newlines: bool,
break_blocks: bool,
) -> Ir {
let mut out: Vec<Ir> = Vec::new();
let mut blocks = MathBlockBoundaries::default();
let mut started = false;
let mut prev_role = MathRole::Relation;
let mut prev_class = MathClass::Rel;
let mut prev_opener = false; let mut prev_delimiter_edge = false;
let mut prev_sized_delimiter = None;
let mut prev_spaced_slash = false;
let mut prev_control_word_operator = false;
let mut prev_ends_control_word = false;
let mut prev_colon_relation_prefix = false;
let mut prev_colon_needs_left_space = false;
let mut prev_atom_ir_index = 0;
let mut pending_space = false; let mut pending_break = false; let mut pending_newline = false; let mut pending_comment_own_line = false; let mut iter = strip_virtual_dtx_framing(elements, cx)
.into_iter()
.peekable();
while let Some(el) = iter.next() {
match el {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {
let gap = consume_gap_widened(&t, &mut iter);
if started {
pending_space = true;
pending_newline = preserve_newlines && gap.newlines > 0;
pending_comment_own_line = gap.newlines > 0;
}
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => {
if pending_break || pending_newline || pending_comment_own_line {
out.push(Ir::hard_line());
} else if pending_space {
out.push(Ir::verbatim(" "));
}
out.push(Ir::verbatim(t.text()));
started = true;
pending_space = false;
pending_newline = false;
pending_comment_own_line = false;
pending_break = true;
}
other => {
let is_line_break = matches!(
&other,
SyntaxElement::Node(n) if n.kind() == SyntaxKind::LINE_BREAK
);
for atom in lower_sized_math_atoms(other, &mut iter, cx, spacing) {
let block_break = break_blocks && blocks.before(&atom);
let completes_colon_relation = prev_colon_relation_prefix
&& atom.starts_equals_relation
&& !pending_space
&& !pending_break
&& !pending_newline;
if completes_colon_relation && prev_colon_needs_left_space {
out[prev_atom_ir_index] =
Ir::concat([Ir::verbatim(" "), out[prev_atom_ir_index].clone()]);
}
let role = math_atom_role(
atom.class,
prev_class,
prev_opener,
atom.postfix_left_limit,
);
let spaced_slash = atom.spaced_slash
|| atom.slash
&& (spacing == MathSpacing::Normal && !prev_role.is_operand_like()
|| spacing == MathSpacing::Script && prev_control_word_operator);
let touches_spaced_slash = prev_spaced_slash || spaced_slash;
let delimiter_edge = matches!(
atom.delimiter,
Some(DelimiterRole::Open | DelimiterRole::Close)
);
let touches_delimiter = prev_delimiter_edge || delimiter_edge;
let spaced_operands = role == MathRole::Operand
&& prev_role == MathRole::Operand
&& pending_space
&& !touches_delimiter;
let script_operator_spacing =
atom.control_word_operator || prev_control_word_operator;
let normal_spacing = spacing == MathSpacing::Normal
&& role != MathRole::PostfixLeftLimit
&& prev_role != MathRole::PostfixLeftLimit
&& (role != MathRole::Operand
|| prev_role != MathRole::Operand
|| pending_space);
let separator_start = out.len();
if !started {
} else if pending_break || pending_newline || block_break {
out.push(Ir::hard_line());
} else if completes_colon_relation {
} else if prev_ends_control_word && atom.starts_control_word_letter {
out.push(Ir::verbatim(" "));
} else if sized_delimiter_space(prev_sized_delimiter, atom.sized_delimiter)
|| touches_spaced_slash
|| normal_spacing
|| spacing == MathSpacing::Script
&& (script_operator_spacing || spaced_operands)
{
out.push(Ir::verbatim(" "));
}
prev_opener = atom.delimiter == Some(DelimiterRole::Open);
prev_delimiter_edge = delimiter_edge;
prev_sized_delimiter = atom.sized_delimiter;
prev_spaced_slash = spaced_slash;
prev_control_word_operator = atom.control_word_operator;
prev_ends_control_word = atom.ends_control_word;
prev_colon_relation_prefix = atom.colon_relation_prefix;
prev_colon_needs_left_space = atom.colon_relation_prefix
&& spacing == MathSpacing::Normal
&& started
&& separator_start == out.len();
prev_atom_ir_index = out.len();
out.push(atom.ir);
started = true;
pending_space = false;
pending_newline = false;
pending_comment_own_line = false;
pending_break = is_line_break;
prev_role = role;
prev_class = atom.class;
}
if is_line_break {
blocks = MathBlockBoundaries::default();
}
}
}
}
if pending_break {
out.push(Ir::hard_line());
}
Ir::concat(out)
}
fn lower_math_element(el: SyntaxElement, cx: LowerCtx<'_>, spacing: MathSpacing) -> Ir {
match el {
SyntaxElement::Node(n) => match n.kind() {
SyntaxKind::SCRIPTED => lower_scripted(&n, cx, spacing),
SyntaxKind::SUBSCRIPT | SyntaxKind::SUPERSCRIPT => lower_script(&n, cx),
SyntaxKind::GROUP => lower_math_group(&n, cx, spacing),
SyntaxKind::LEFT_RIGHT => lower_left_right(&n, cx, spacing),
SyntaxKind::COMMAND if command_has_math_arg(&n, cx) => {
lower_command_with_math_spacing(&n, cx, spacing)
}
SyntaxKind::COMMAND => Ir::verbatim(n.text().to_string()),
SyntaxKind::ENVIRONMENT => Ir::align_current(lower_node(&n, cx)),
_ => lower_node(&n, cx),
},
SyntaxElement::Token(t) => lower_loose_token(&t, cx),
}
}
fn lower_math_group(node: &SyntaxNode, cx: LowerCtx<'_>, spacing: MathSpacing) -> Ir {
let inner = node
.children_with_tokens()
.filter(|el| !matches!(el.kind(), SyntaxKind::L_BRACE | SyntaxKind::R_BRACE));
Ir::concat([
Ir::verbatim("{"),
Ir::align(1, lower_math_seq(inner, cx, spacing, false)),
Ir::verbatim("}"),
])
}
fn lower_math_argument_group(node: &SyntaxNode, cx: LowerCtx<'_>, spacing: MathSpacing) -> Ir {
let (open_kind, close_kind, open, close) = match node.kind() {
SyntaxKind::GROUP => (SyntaxKind::L_BRACE, SyntaxKind::R_BRACE, "{", "}"),
SyntaxKind::OPTIONAL => (SyntaxKind::L_BRACKET, SyntaxKind::R_BRACKET, "[", "]"),
_ => return Ir::verbatim(node.text().to_string()),
};
let inner = node.children_with_tokens().filter(
|element| !matches!(element.kind(), kind if kind == open_kind || kind == close_kind),
);
Ir::concat([
Ir::verbatim(open),
Ir::align(1, lower_math_seq(inner, cx, spacing, false)),
Ir::verbatim(close),
])
}
fn lower_left_right(node: &SyntaxNode, cx: LowerCtx<'_>, spacing: MathSpacing) -> Ir {
let mut parts: Vec<Ir> = Vec::new();
let mut open_width = 0usize;
let mut seen_body = false;
for el in node.children_with_tokens() {
match el {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => {}
SyntaxElement::Node(n) if n.kind() == SyntaxKind::MATH => {
seen_body = true;
if !math_body_is_empty(&n) {
parts.push(Ir::align(
open_width + 1,
Ir::concat([
Ir::verbatim(" "),
lower_math_seq(n.children_with_tokens(), cx, spacing, false),
Ir::verbatim(" "),
]),
));
}
}
SyntaxElement::Token(t) => {
if !seen_body {
open_width += t.text().chars().count();
}
parts.push(Ir::verbatim(t.text()));
}
SyntaxElement::Node(n) => parts.push(lower_node(&n, cx)),
}
}
Ir::concat(parts)
}
fn math_body_is_empty(node: &SyntaxNode) -> bool {
node.text().to_string().trim().is_empty()
}
fn lower_scripted(node: &SyntaxNode, cx: LowerCtx<'_>, spacing: MathSpacing) -> Ir {
Ir::concat(
strip_virtual_dtx_framing(node.children_with_tokens(), cx)
.into_iter()
.filter_map(|el| match el {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => None,
SyntaxElement::Node(n)
if matches!(n.kind(), SyntaxKind::SUBSCRIPT | SyntaxKind::SUPERSCRIPT) =>
{
Some(lower_script(&n, cx))
}
other => Some(lower_math_element(other, cx, spacing)),
}),
)
}
fn lower_script(node: &SyntaxNode, cx: LowerCtx<'_>) -> Ir {
Ir::concat(
strip_virtual_dtx_framing(node.children_with_tokens(), cx)
.into_iter()
.filter_map(|el| match el {
SyntaxElement::Token(t) if is_collapsible_trivia(t.kind()) => None,
SyntaxElement::Token(t)
if matches!(t.kind(), SyntaxKind::CARET | SyntaxKind::UNDERSCORE) =>
{
Some(Ir::verbatim(t.text()))
}
other => Some(lower_math_element(other, cx, MathSpacing::Script)),
}),
)
}
fn spans_multiple_lines(node: &SyntaxNode) -> bool {
node.children_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| t.kind() == SyntaxKind::NEWLINE)
}
fn contains_doc_margin(node: &SyntaxNode, cx: LowerCtx<'_>) -> bool {
if !cx.is_dtx || cx.in_dtx_doc_region {
return false;
}
node.descendants_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| matches!(t.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD))
}
fn block_rides_own_margins(node: &SyntaxNode) -> bool {
let tokens: Vec<SyntaxToken> = node
.descendants_with_tokens()
.filter_map(|e| e.into_token())
.collect();
let mut saw_newline = false;
for (i, token) in tokens.iter().enumerate() {
if !token.text().contains('\n') {
continue;
}
if token.kind() != SyntaxKind::NEWLINE {
return false;
}
saw_newline = true;
if !tokens
.get(i + 1)
.is_some_and(|next| matches!(next.kind(), SyntaxKind::DOC_MARGIN | SyntaxKind::GUARD))
{
return false;
}
}
saw_newline
}
fn has_verbatim_body(node: &SyntaxNode) -> bool {
node.children_with_tokens()
.filter_map(|e| e.into_token())
.any(|t| t.kind() == SyntaxKind::VERBATIM_BODY)
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Gap {
Glued,
Space { flat: String },
Blank,
Comment,
}
impl Gap {
fn space() -> Gap {
Gap::Space {
flat: " ".to_string(),
}
}
fn from_run(newlines: usize, trailing_ws: String) -> Gap {
match newlines {
0 => Gap::Space { flat: trailing_ws },
1 => Gap::space(),
_ => Gap::Blank,
}
}
fn flat(&self) -> &str {
match self {
Gap::Space { flat } => flat,
Gap::Blank => " ",
Gap::Glued | Gap::Comment => "",
}
}
fn separator(&self) -> Ir {
match self {
Gap::Glued => Ir::soft_line(),
_ => Ir::line(),
}
}
}
struct WideGap {
gap: Gap,
newlines: usize,
}
impl WideGap {
fn narrow(self) -> Gap {
self.gap
}
}
fn consume_gap(
first: &SyntaxToken,
iter: &mut Peekable<impl Iterator<Item = SyntaxElement>>,
) -> Gap {
consume_gap_widened(first, iter).narrow()
}
fn consume_gap_widened(
first: &SyntaxToken,
iter: &mut Peekable<impl Iterator<Item = SyntaxElement>>,
) -> WideGap {
let mut newlines = 0;
let mut trailing_ws = String::new();
absorb(first, &mut newlines, &mut trailing_ws);
loop {
match iter.peek() {
Some(SyntaxElement::Token(tok)) if is_collapsible_trivia(tok.kind()) => {}
_ => break,
}
let token = match iter.next() {
Some(SyntaxElement::Token(tok)) => tok,
_ => unreachable!("peeked a collapsible trivia token"),
};
absorb(&token, &mut newlines, &mut trailing_ws);
}
WideGap {
gap: Gap::from_run(newlines, trailing_ws),
newlines,
}
}
fn consume_widened_gap_slice(elements: &[SyntaxElement], i: &mut usize) -> usize {
let mut newlines = 0;
while let Some(SyntaxElement::Token(tok)) = elements.get(*i) {
if !is_collapsible_trivia(tok.kind()) {
break;
}
if tok.kind() == SyntaxKind::NEWLINE {
newlines += 1;
}
*i += 1;
}
newlines
}
fn line_is_command_only(elements: &[SyntaxElement], start: usize, cx: LowerCtx<'_>) -> bool {
let mut saw_command = false;
for element in &elements[start..] {
match element {
SyntaxElement::Token(t) if t.kind() == SyntaxKind::NEWLINE => break,
SyntaxElement::Token(t) if t.kind() == SyntaxKind::COMMENT => break,
SyntaxElement::Token(t) if cx.is_dtx && t.kind() == SyntaxKind::DOC_MARGIN => {
continue;
}
SyntaxElement::Token(t) if t.kind() == SyntaxKind::WHITESPACE => continue,
SyntaxElement::Node(n)
if n.kind() == SyntaxKind::COMMAND && !command_is_inline(n, cx) =>
{
saw_command = true
}
_ => return false,
}
}
saw_command
}
fn next_is_separated(elements: &[SyntaxElement], idx: usize) -> bool {
match elements.get(idx + 1) {
None => true,
Some(SyntaxElement::Token(t)) => matches!(
t.kind(),
SyntaxKind::WHITESPACE | SyntaxKind::NEWLINE | SyntaxKind::COMMENT
),
Some(SyntaxElement::Node(_)) => false,
}
}
fn next_nontrivia_is_label(elements: &[SyntaxElement], idx: usize, cx: LowerCtx<'_>) -> bool {
elements[idx + 1..]
.iter()
.find(|element| !is_section_label_framing(element, cx))
.is_some_and(|element| {
matches!(element, SyntaxElement::Node(node) if node.kind() == SyntaxKind::COMMAND && command_is_label(node))
})
}
fn is_section_label_framing(element: &SyntaxElement, cx: LowerCtx<'_>) -> bool {
is_collapsible_trivia_element(element)
|| matches!(element, SyntaxElement::Token(token) if cx.is_dtx && token.kind() == SyntaxKind::DOC_MARGIN)
}
fn label_follows_sectioning_run(elements: &[SyntaxElement], idx: usize, cx: LowerCtx<'_>) -> bool {
for element in elements[..idx].iter().rev() {
match element {
element if is_section_label_framing(element, cx) => {}
SyntaxElement::Node(node)
if node.kind() == SyntaxKind::COMMAND && command_is_label(node) => {}
SyntaxElement::Node(node)
if node.kind() == SyntaxKind::COMMAND && command_is_sectioning(node, cx) =>
{
return node
.parent()
.is_some_and(|parent| parent.kind() == SyntaxKind::PARAGRAPH);
}
_ => return false,
}
}
false
}
fn absorb(tok: &SyntaxToken, newlines: &mut usize, trailing_ws: &mut String) {
if tok.kind() == SyntaxKind::NEWLINE {
*newlines += 1;
trailing_ws.clear();
} else {
trailing_ws.push_str(tok.text());
}
}
fn classify_trivia(gap: WideGap, soften_newline: bool) -> Ir {
match gap.newlines {
0 => Ir::verbatim(gap.gap.flat()),
1 if soften_newline => Ir::line(),
1 => Ir::hard_line(),
_ => Ir::empty_line(),
}
}
fn is_trimmable_break(ir: &Ir) -> bool {
match ir {
Ir::HardLine | Ir::PreservedLine | Ir::EmptyLine | Ir::Nil => true,
Ir::Verbatim { text, force_break } => {
!force_break && text.chars().all(|c| c == ' ' || c == '\t')
}
_ => false,
}
}
fn peel_leading_break(ir: Ir) -> (bool, Ir) {
if is_trimmable_break(&ir) {
return (matches!(ir, Ir::EmptyLine), Ir::Nil);
}
match ir {
Ir::Concat(items) => {
let mut v: Vec<Ir> = items.iter().cloned().collect();
let mut blank = false;
while !v.is_empty() {
let (b, head) = peel_leading_break(v.remove(0));
blank |= b;
if matches!(head, Ir::Nil) {
continue;
}
v.insert(0, head);
break;
}
(blank, Ir::concat(v))
}
other => (false, other),
}
}
fn peel_trailing_break(ir: Ir) -> (bool, Ir) {
if is_trimmable_break(&ir) {
return (matches!(ir, Ir::EmptyLine), Ir::Nil);
}
match ir {
Ir::Concat(items) => {
let mut v: Vec<Ir> = items.iter().cloned().collect();
let mut blank = false;
while let Some(last) = v.pop() {
let (b, tail) = peel_trailing_break(last);
blank |= b;
if matches!(tail, Ir::Nil) {
continue;
}
v.push(tail);
break;
}
(blank, Ir::concat(v))
}
other => (false, other),
}
}
fn trim_leading_break(ir: Ir) -> Ir {
peel_leading_break(ir).1
}
fn trim_trailing_break(ir: Ir) -> Ir {
peel_trailing_break(ir).1
}
#[cfg(test)]
mod expl3_region_tests {
use super::*;
use crate::parser::parse;
fn grouped_sibling_walk(input: &str, marker: &str) -> bool {
let parsed = parse(input);
assert!(parsed.errors.is_empty(), "test input should parse cleanly");
let root = parsed.syntax();
let group = root
.descendants()
.filter(|n| n.kind() == SyntaxKind::GROUP && n.text().to_string().contains(marker))
.last()
.expect("a group containing the marker");
head_command_has_grouped_sibling_arg(&group)
}
#[test]
fn grouped_sibling_walk_stops_at_the_statement_boundary() {
let src = "\\ExplSyntaxOn\n\\tl_set:Nn \\l_x { v }\n\\bool_if:NF \\l_bool { body }\n\\ExplSyntaxOff\n";
assert!(!grouped_sibling_walk(src, "body"));
let src = "\\ExplSyntaxOn\n\\prop_get:NnNTF \\g_prop {#2} \\l_tl { branch } { f }\n\\ExplSyntaxOff\n";
assert!(grouped_sibling_walk(src, "branch"));
let src =
"\\ExplSyntaxOn\n\\prop_get:NnNTF \\g_prop {#2} \\l_tl { branch }\n\\ExplSyntaxOff\n";
assert!(!grouped_sibling_walk(src, "branch"));
}
#[test]
fn grouped_sibling_walk_matches_the_body_stream_segmentation() {
let src = "\\ExplSyntaxOn\n\\use:n { \\tl_set:Nn \\l_x { v } \\bool_if:NF \\l_b { body } }\n\\ExplSyntaxOff\n";
assert!(!grouped_sibling_walk(src, "body"));
}
#[test]
fn grouped_sibling_walk_ignores_out_of_region_prefix() {
let src = "x \\emph{y} \\ExplSyntaxOn \\tl_put_right:Ne \\l_t { body } \\ExplSyntaxOff\n";
assert!(!grouped_sibling_walk(src, "body"));
}
fn regions(input: &str) -> Vec<(usize, usize)> {
let parsed = parse(input);
assert!(parsed.errors.is_empty(), "test input should parse cleanly");
expl3_regions(&parsed.syntax())
.into_iter()
.map(|r| (r.start().into(), r.end().into()))
.collect()
}
#[test]
fn on_off_pair_spans_both_toggles() {
let input = r"a \ExplSyntaxOn b \ExplSyntaxOff c";
let start = input.find(r"\ExplSyntaxOn").unwrap();
let end = input.find(r"\ExplSyntaxOff").unwrap() + r"\ExplSyntaxOff".len();
assert_eq!(regions(input), vec![(start, end)]);
}
#[test]
fn unclosed_region_runs_to_eof() {
let input = r"x \ExplSyntaxOn y z";
let start = input.find(r"\ExplSyntaxOn").unwrap();
assert_eq!(regions(input), vec![(start, input.len())]);
}
#[test]
fn provides_expl_opens_to_eof() {
let input = "\\ProvidesExplPackage\n\\cs_new:N \\foo:";
assert_eq!(regions(input), vec![(0, input.len())]);
}
#[test]
fn definee_provides_does_not_open_region() {
let input = "\\protected\\def\\ProvidesExplPackage{\\ProvidesPackage{demo}}\ntext";
assert!(regions(input).is_empty());
}
#[test]
fn definee_off_does_not_close_a_real_region() {
let input = "\\ExplSyntaxOn a \\let\\ExplSyntaxOff\\relax b";
assert_eq!(regions(input), vec![(0, input.len())]);
}
#[test]
fn stored_toggle_in_group_does_not_open_region() {
let input = "\\def\\store{\\ExplSyntaxOn \\foo:n {x}}\ntext";
assert!(regions(input).is_empty());
}
#[test]
fn top_level_provides_after_gated_definee_still_opens() {
let input = "\\def\\x{\\ExplSyntaxOn}\n\\ProvidesExplPackage\n\\cs_new:N \\foo:";
let start = input.rfind("\\ProvidesExplPackage").unwrap();
assert_eq!(regions(input), vec![(start, input.len())]);
}
#[test]
fn stray_off_is_ignored() {
assert!(regions(r"a \ExplSyntaxOff b").is_empty());
}
#[test]
fn redundant_inner_on_does_not_restart() {
let input = r"\ExplSyntaxOn a \ExplSyntaxOn b \ExplSyntaxOff";
let end = input.find(r"\ExplSyntaxOff").unwrap() + r"\ExplSyntaxOff".len();
assert_eq!(regions(input), vec![(0, end)]);
}
#[test]
fn toggle_inside_verb_is_not_a_region() {
assert!(regions(r"\verb|\ExplSyntaxOn| text").is_empty());
}
#[test]
fn toggle_inside_comment_is_not_a_region() {
assert!(regions("% \\ExplSyntaxOn\ntext").is_empty());
}
fn regions_dtx(input: &str) -> Vec<(usize, usize)> {
let config = crate::parser::LexConfig {
flavor: LatexFlavor::Document,
dtx: true,
};
let parsed = parse_with_flavor(input, config);
assert!(parsed.errors.is_empty(), "test input should parse cleanly");
expl3_regions(&parsed.syntax())
.into_iter()
.map(|r| (r.start().into(), r.end().into()))
.collect()
}
#[test]
fn dtx_region_owns_only_macrocode_bodies() {
let input = "% \\begin{macrocode}\n\
\\ExplSyntaxOn\n\
% \\end{macrocode}\n\
\x20%\n\
% doc\n\
% \\begin{macrocode}\n\
\\foo\n\
% \\end{macrocode}\n";
let first_frame = input.find("% \\end{macrocode}").unwrap();
let second_body = input.find("\\foo").unwrap();
let second_frame = input.rfind("% \\end{macrocode}").unwrap();
assert_eq!(
regions_dtx(input),
vec![
(input.find("\\ExplSyntaxOn").unwrap(), first_frame),
(second_body, second_frame),
]
);
}
}
#[cfg(test)]
mod gap_tests {
use super::*;
use crate::parser::parse;
fn first_gap(input: &str) -> Gap {
let parsed = parse(input);
assert!(parsed.errors.is_empty(), "test input should parse cleanly");
for node in parsed.syntax().descendants() {
let mut iter = node.children_with_tokens().peekable();
while let Some(element) = iter.next() {
let SyntaxElement::Token(token) = element else {
continue;
};
if is_collapsible_trivia(token.kind()) {
return consume_gap(&token, &mut iter);
}
}
}
panic!("no trivia run in {input:?}");
}
#[test]
fn a_lone_newline_and_a_space_are_the_same_gap() {
assert_eq!(first_gap("\\foo{a b}"), first_gap("\\foo{a\nb}"));
assert_eq!(first_gap("\\foo{a\nb}"), Gap::space());
assert_eq!(first_gap("\\foo{a\n b}"), Gap::space());
assert_eq!(first_gap("\\foo{a \n b}"), Gap::space());
}
#[test]
fn a_blank_line_stays_visible() {
assert_eq!(first_gap("\\foo{a\n\nb}"), Gap::Blank);
assert_eq!(first_gap("\\foo{a\n\n\nb}"), Gap::Blank);
assert_eq!(Gap::Blank.flat(), " ");
}
#[test]
fn a_wide_run_rides_verbatim() {
assert_eq!(
first_gap("\\foo{a b}"),
Gap::Space {
flat: " ".to_string()
}
);
assert_ne!(first_gap("\\foo{a b}"), first_gap("\\foo{a\nb}"));
}
#[test]
fn a_glued_junction_separates_without_a_flat_space() {
assert!(matches!(Gap::Glued.separator(), Ir::SoftLine));
assert_eq!(Gap::Glued.flat(), "");
assert!(matches!(Gap::space().separator(), Ir::Line));
assert!(matches!(Gap::Blank.separator(), Ir::Line));
assert!(matches!(Gap::Comment.separator(), Ir::Line));
}
}