Enum difft::parse::syntax::Syntax

pub(crate) enum Syntax<'a> {
    List {
        info: SyntaxInfo<'a>,
        open_position: Vec<SingleLineSpan>,
        open_content: String,
        children: Vec<&'a Syntax<'a>>,
        close_position: Vec<SingleLineSpan>,
        close_content: String,
        num_descendants: u32,
    },
    Atom {
        info: SyntaxInfo<'a>,
        position: Vec<SingleLineSpan>,
        content: String,
        kind: AtomKind,
    },
}

Variants

List

Fields

info: SyntaxInfo<'a>

open_position: Vec<SingleLineSpan>

open_content: String

children: Vec<&'a Syntax<'a>>

close_position: Vec<SingleLineSpan>

close_content: String

num_descendants: u32

Atom

Fields

info: SyntaxInfo<'a>

position: Vec<SingleLineSpan>

content: String

kind: AtomKind

Implementations

impl<'a> Syntax<'a>

fn first_line_span(&self) -> Option<SingleLineSpan>

fn last_line_span(&self) -> Option<SingleLineSpan>

impl<'a> Syntax<'a>

pub(crate) fn new_list(
    arena: &'a Arena<Syntax<'a>>,
    open_content: &str,
    open_position: Vec<SingleLineSpan>,
    children: Vec<&'a Syntax<'a>>,
    close_content: &str,
    close_position: Vec<SingleLineSpan>
) -> &'a Syntax<'a>

pub(crate) fn new_atom(
    arena: &'a Arena<Syntax<'a>>,
    position: Vec<SingleLineSpan>,
    content: &str,
    kind: AtomKind
) -> &'a Syntax<'a>

pub(crate) fn info(&self) -> &SyntaxInfo<'a>

pub(crate) fn parent(&self) -> Option<&'a Syntax<'a>>

pub(crate) fn next_sibling(&self) -> Option<&'a Syntax<'a>>

pub(crate) fn id(&self) -> NonZeroU32

A unique ID of this syntax node. Every node is guaranteed to have a different value.

pub(crate) fn content_id(&self) -> u32

A content ID of this syntax node. Two nodes have the same content ID if they have the same content, regardless of position.

pub(crate) fn content_is_unique(&self) -> bool

pub(crate) fn num_ancestors(&self) -> u32

pub(crate) fn dbg_content(&self) -> String

Trait Implementations

impl<'a> Debug for Syntax<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<Syntax<'a>> for Syntax<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for Syntax<'a>