Struct LineOffsetTable 

pub struct LineOffsetTable { /* private fields */ }

Converts byte offsets in source text to LSP Position values.

Precomputes line-start byte offsets once, then maps any byte offset to a (line, character) position. Characters are counted as UTF-16 code units as required by the LSP specification.

Also precomputes, per line, whether that line is pure ASCII (line_is_ascii): for an ASCII-only line, byte offset and UTF-16 code-unit offset are always equal, so byte_offset_to_position can skip the chars().map(char::len_utf16).sum() scan entirely and compute the character offset in O(1). This matters because a single minified manifest line (e.g. a package.json with hundreds of dependencies on one line) turns per-offset lookups into an O(n) scan each, and O(n) lookups across the line’s length make the whole document O(n^2) (#742) — the common case of an ASCII-only line now stays O(1) per lookup; a non-ASCII line still takes an O(1) lookup too, via a lazily-built per-line index (#882) — see with_non_ascii_line_index.

Interior mutability: this type is Send but not Sync (the non-ASCII line index cache uses a RefCell). Build one per document parse and never share it across threads.

Implementations

impl LineOffsetTable

pub fn new(content: &str) -> Self

Builds the table for content.

pub fn line_start(&self, line: usize) -> Option<usize>

Absolute byte offset where line (0-indexed) starts, or None if line is out of range.

Prefer this over re-deriving a line’s start via cursor arithmetic (cursor += line.len() + 1): str::lines() strips a trailing \r, so that approach under-counts by one byte per CRLF line and corrupts every subsequent offset in the file. This table is built by scanning char_indices() for \n (see new), which counts the \r, so it stays correct for LF, CRLF and mixed line endings alike.

Examples

use deps_core::lsp_helpers::LineOffsetTable;

let table = LineOffsetTable::new("a\r\nb\r\nc");
assert_eq!(table.line_start(0), Some(0));
assert_eq!(table.line_start(1), Some(3));
assert_eq!(table.line_start(2), Some(6));
assert_eq!(table.line_start(3), None);

pub fn byte_offset_to_position(&self, content: &str, offset: usize) -> Position

Converts a byte offset into an LSP Position.

pub fn position_to_byte_offset( &self, content: &str, position: Position, ) -> usize

Converts an LSP Position back into a byte offset — the inverse of byte_offset_to_position. Out-of-range lines or UTF-16 characters clamp to content.len() rather than panicking, matching the forward conversion’s .min(content.len()) guard.

A character landing inside a surrogate pair rounds up to the next char boundary, and one past the line’s end (including its \n) resolves to the line’s end — the same results as utf16_to_byte_offset on the line, but O(1) on an ASCII line and O(log line length) on a non-ASCII one via the cached per-line index (#1711).