Struct Entry

pub struct Entry<'node> {
    pub reference: Node<'node>,
    pub text: Cow<'node, str>,
    pub start_position: Point,
    pub end_position: Point,
    pub kind_id: u16,
}

A mapping between a tree-sitter node and the text it corresponds to

This is also all of the metadata the diff rendering interface has access to, and also defines the data that will be output by the JSON serializer.

Fields

reference: Node<'node>

The node an entry in the diff vector refers to

We keep a reference to the leaf node so that we can easily grab the text and other metadata surrounding the syntax

text: Cow<'node, str>

A reference to the text the node refers to

This is different from the source_text that the [AstVector] refers to, as the entry only holds a reference to the specific range of text that the node covers.

We use a Cow here instead of a direct string reference because we might have to rewrite the text based on input processing settings, but if we don’t have to there’s no need to allocate an extra string.

start_position: Point

The entry’s start position in the document.

end_position: Point

The entry’s end position in the document.

kind_id: u16

The cached kind_id from the TSNode reference.

Caching it here saves some time because it is queried repeatedly later. If we don’t store it inline then we have to cross the FFI boundary which incurs some overhead.

Implementations

impl<'a> Entry<'a>

pub fn start_position(&self) -> Point

Get the start position of an entry

pub fn end_position(&self) -> Point

Get the end position of an entry

Trait Implementations

impl<'node> Clone for Entry<'node>

fn clone(&self) -> Entry<'node>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'node> Debug for Entry<'node>

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

Formats the value using the given formatter.

impl<'a> From<VectorLeaf<'a>> for Entry<'a>

fn from(leaf: VectorLeaf<'a>) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<&'a Entry<'a>> for HunkAppender<'a>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = &'a Entry<'a>>,

Create an instance of Hunks from an iterator over entries.

The user is responsible for making sure that the hunks are in proper order, otherwise this constructor may panic.

impl<'a> PartialEq for Entry<'a>

fn eq(&self, other: &Entry<'_>) -> bool

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

const 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<'node> Serialize for Entry<'node>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Entry<'a>