Struct Injection 

pub struct Injection {
    pub language_id: String,
    pub ranges: Vec<Range<usize>>,
    pub start_row: u32,
    pub start_col: u32,
    pub end_row: u32,
    pub end_col: u32,
}

An injection point for embedded languages.

Injections allow one language to be embedded within another, such as code blocks in markdown or script tags in HTML.

Single vs Combined Injections

• Single-range: A fenced code block in Markdown produces one injection with one byte range (e.g., the code block content).
• Combined: Consecutive doc comment lines (///) produce one injection with multiple byte ranges (one per comment line), merged via #set! injection.combined.

Example

use reovim_driver_syntax::Injection;

// A Rust code block in a markdown file
let inj = Injection::new("rust", 100..200, 5, 3, 10, 3);
assert_eq!(inj.language_id, "rust");
assert!(inj.overlaps_lines(6, 8));

Fields

language_id: String

The language ID to use for the injected region.

ranges: Vec<Range<usize>>

Byte ranges in the parent document. Single-range injections (fenced code blocks) have exactly one element. Combined injections (doc comment lines) have multiple elements.

start_row: u32

Start row (0-indexed) of the first range.

start_col: u32

Start column (0-indexed) of the first range.

end_row: u32

End row (0-indexed) of the last range.

end_col: u32

End column (0-indexed) of the last range.

Implementations

impl Injection

pub fn new( language_id: impl Into<String>, byte_range: Range<usize>, start_row: u32, start_col: u32, end_row: u32, end_col: u32, ) -> Self

Create a new single-range injection.

pub fn combined( language_id: impl Into<String>, ranges: Vec<Range<usize>>, start_row: u32, start_col: u32, end_row: u32, end_col: u32, ) -> Self

Create a combined injection from multiple byte ranges.

Used for injection.combined patterns where multiple source nodes (e.g., consecutive doc comment lines) map to a single injection.

pub fn from_bytes( language_id: impl Into<String>, byte_range: Range<usize>, ) -> Self

Create an injection from byte range only (row/col set to 0).

Useful when only byte positions are known.

pub fn byte_range(&self) -> Range<usize>

Get the overall byte range (start of first range to end of last range).

For single-range injections, this is identical to the original range. For combined injections, this spans the entire region.

pub const fn overlaps_lines(&self, start_line: u32, end_line: u32) -> bool

Check if this injection overlaps with a line range.

Both start_line and end_line are inclusive.

pub const fn contains_line(&self, line: u32) -> bool

Check if this injection contains a specific line.

pub fn overlaps_bytes(&self, range: &Range<usize>) -> bool

Check if this injection overlaps with a byte range.

pub fn byte_len(&self) -> usize

Get the total number of bytes across all ranges.

pub const fn is_multiline(&self) -> bool

Check if this injection spans multiple lines.

pub const fn line_count(&self) -> u32

Get the number of lines spanned by this injection.

pub const fn is_combined(&self) -> bool

Check if this is a combined injection (multiple ranges).

Trait Implementations

impl Clone for Injection

fn clone(&self) -> Injection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Injection

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

Formats the value using the given formatter.

impl PartialEq for Injection

fn eq(&self, other: &Injection) -> 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 Eq for Injection

impl StructuralPartialEq for Injection