Struct Document 

pub struct Document {
    pub annotations: Vec<Annotation>,
    pub root: Session,
}

Fields

annotations: Vec<Annotation>

root: Session

Implementations

impl Document

pub fn diagnostics(&self) -> Vec<Diagnostic>

Get all diagnostics for this document

This collects diagnostics from various validation checks:

• Broken references (footnotes, citations, session links)
• Malformed structures (single-item lists, etc.)
• Invalid annotation syntax

Example

let doc = parse_document(source)?;
let diagnostics = doc.diagnostics();
for diag in diagnostics {
    eprintln!("{}", diag);
}

impl Document

pub fn new() -> Self

pub fn with_content(content: Vec<ContentItem>) -> Self

pub fn from_root(root: Session) -> Self

Construct a document from an existing root session.

pub fn with_annotations_and_content( annotations: Vec<Annotation>, content: Vec<ContentItem>, ) -> Self

pub fn with_root_location(self, location: Range) -> Self

pub fn root_session(&self) -> &Session

pub fn root_session_mut(&mut self) -> &mut Session

pub fn into_root(self) -> Session

pub fn title(&self) -> &str

Get the document title.

This delegates to the root session’s title.

pub fn set_title(&mut self, title: String)

Set the document title.

This updates the root session’s title.

pub fn node_path_at_position(&self, pos: Position) -> Vec<&dyn AstNode>

Returns the path of nodes at the given position, starting from the document

pub fn element_at(&self, pos: Position) -> Option<&ContentItem>

Returns the deepest (most nested) element that contains the position

pub fn visual_line_at(&self, pos: Position) -> Option<&ContentItem>

Returns the visual line element at the given position

pub fn block_element_at(&self, pos: Position) -> Option<&ContentItem>

Returns the block element at the given position

pub fn annotations(&self) -> &[Annotation]

All annotations attached directly to the document (document-level metadata).

pub fn annotations_mut(&mut self) -> &mut Vec<Annotation>

Mutable access to document-level annotations.

pub fn iter_annotations(&self) -> Iter<'_, Annotation>

Iterate over document-level annotation blocks in source order.

pub fn iter_annotation_contents(&self) -> impl Iterator<Item = &ContentItem>

Iterate over all content items nested inside document-level annotations.

pub fn find_annotation_by_label(&self, label: &str) -> Option<&Annotation>

Find the first annotation with a matching label.

This searches recursively through all annotations in the document, including both document-level annotations and annotations in the content tree.

Arguments

• label - The label string to search for

Returns

The first annotation whose label matches exactly, or None if not found.

Example

// Find annotation with label "42" for reference [42]
if let Some(annotation) = document.find_annotation_by_label("42") {
    // Jump to this annotation in go-to-definition
}

pub fn find_annotations_by_label(&self, label: &str) -> Vec<&Annotation>

Find all annotations with a matching label.

This searches recursively through all annotations in the document, including both document-level annotations and annotations in the content tree.

Arguments

• label - The label string to search for

Returns

A vector of all annotations whose labels match exactly.

Example

// Find all annotations labeled "note"
let notes = document.find_annotations_by_label("note");
for note in notes {
    // Process each note annotation
}

pub fn iter_all_references( &self, ) -> Box<dyn Iterator<Item = ReferenceInline> + '_>

Iterate all inline references at any depth.

This method recursively walks the document tree, parses inline content, and yields all reference inline nodes (e.g., [42], [@citation], [^note]).

Returns

An iterator of references to ReferenceInline nodes

Example

for reference in document.iter_all_references() {
    match &reference.reference_type {
        ReferenceType::FootnoteNumber { number } => {
            // Find annotation with this number
        }
        ReferenceType::Citation(data) => {
            // Process citation
        }
        _ => {}
    }
}

pub fn find_references_to(&self, target: &str) -> Vec<ReferenceInline>

Find all references to a specific target label.

This method searches for inline references that point to the given target. For example, find all [42] references when looking for footnote “42”.

Arguments

• target - The target label to search for

Returns

A vector of references to ReferenceInline nodes that match the target

Example

// Find all references to footnote "42"
let refs = document.find_references_to("42");
println!("Found {} references to footnote 42", refs.len());

impl Document

pub fn find_all_links(&self) -> Vec<DocumentLink>

Find all links in the entire document

This searches the entire document tree to find all clickable links:

• URL references in text
• File references in text
• Verbatim block src parameters

Returns

Vector of all links found in the document

Example

let doc = parse_document(source)?;
let links = doc.find_all_links();
for link in links {
    // Make link clickable in LSP
    send_document_link(link.range, link.target);
}

Trait Implementations

impl AstNode for Document

fn node_type(&self) -> &'static str

fn display_label(&self) -> String

fn range(&self) -> &Range

fn accept(&self, visitor: &mut dyn Visitor)

Accept a visitor for traversing this node and its children

fn start_position(&self) -> Position

impl Clone for Document

fn clone(&self) -> Document

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Document

fn default() -> Self

Returns the “default value” for a type.

impl Display for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Document

fn eq(&self, other: &Document) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Runnable<Document, Document> for AttachAnnotations

fn run(&self, input: Document) -> Result<Document, TransformError>

Execute this transformation on the input

impl Runnable<Session, Document> for AttachRoot

fn run(&self, root: Session) -> Result<Document, TransformError>

Execute this transformation on the input

impl StructuralPartialEq for Document