Struct ParsedBuffer 

pub struct ParsedBuffer {
    pub lines: Vec<ParsedLine>,
    pub kinds: Vec<LineConstructKind>,
    pub reset_boundaries: Vec<usize>,
    pub lazy_depth: Vec<u32>,
}

Fields

lines: Vec<ParsedLine>

kinds: Vec<LineConstructKind>

reset_boundaries: Vec<usize>

Sorted, deduped row indices b where pulldown-cmark’s parser state is provably reset — i.e. parsing &lines[b..j] in isolation produces the same ParsedLine and LineConstructKind for row b as parsing the full buffer would, for every later boundary j. Used by parse_incremental::expand_to_reset_boundary so the incremental-parse widening is provably-equivalent to a fresh parse over the spliced range — no post-slice verification needed in release.

Always contains 0 and lines.len() as sentinel boundaries. Conservative starting set: only Blank-prefixed rows after an Event::End of a top-level block. Long buffers without blank separators degrade to full-rebuild on every edit (acceptable — same behaviour as today’s widen_to_safe + cap-trip path in that regime).

lazy_depth: Vec<u32>

Per-row lazy-construct depth AFTER processing the row’s open events (i.e. the prefix sum is applied row-by-row INCLUDING the current row’s deltas before being stored). Counts ONLY constructs that CommonMark allows to extend across blank rows (List, BlockQuote, IndentedCode, HtmlBlock — see [is_lazy_continuable_tag]). Fenced code, Paragraph, Heading are NOT counted because their parse state is reset at blank rows or single-row terminators.

lazy_depth[r] == 0 is a necessary precondition for treating row r as a reset boundary: at depth 0 there is no open lazy-extendable construct that a fresh parser starting at r could miss.

Implementations

impl ParsedBuffer

pub fn parse(lines: &[String]) -> ParsedBuffer

Parse the entire editor buffer in a single pulldown-cmark pass.

Returns a ParsedBuffer whose lines contains one ParsedLine per input row (multi-row markdown elements split per row) and whose kinds contains the per-row LineConstructKind classification that drives safe-boundary widening in parse_incremental.

The pulldown-cmark event walk classifies the major constructs inline; three short O(n) post-passes (list-continuation, blockquote-depth, setext-underline) refine the result. No second invocation of the pulldown parser.

pub fn placeholder(lines: &[String]) -> ParsedBuffer

O(N) placeholder buffer matching lines’s row count, every row classified Plain, every char marked content-visible, no elements. Used by view.update’s async-fallback path (perf #9 in the holistic review) to install a structurally-correct ParsedBuffer cheaply while the real ParsedBuffer::parse runs on a background tokio task. Render produces unstyled markdown for one frame until the async result is installed via install_full_parse.

pub fn parse_range(lines: &[String], range: Range<usize>) -> ParsedBuffer

Parse a contiguous slice of lines as if it were a standalone document.

Boundary contract: the caller must pass a range whose start and end land on safe construct boundaries (verified by parse_incremental::widen_to_safe or expand_to_reset_boundary). This function does not validate the contract — passing a mid-fence range will produce a ParsedBuffer that mis-classifies the boundary lines.

Returns a ParsedBuffer whose lines.len() == kinds.len() == range.len(). The returned reset_boundaries are in slice-local index space (0..range.len()); splice shifts them by range.start when merging into the parent buffer’s boundary set.

pub fn splice(&mut self, range: Range<usize>, other: ParsedBuffer)

Replace self.lines[range] and self.kinds[range] with the contents of other. Both other vectors must have range.len() entries.

Trait Implementations

impl Clone for ParsedBuffer

fn clone(&self) -> ParsedBuffer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.