mod builder; pub mod syntax_error; mod syntax_text; use self::syntax_text::SyntaxText; use crate::{SmolStr, SyntaxKind, TextRange}; use rowan::Types; use std::{ fmt, hash::{Hash, Hasher}, }; pub(crate) use self::builder::GreenBuilder; pub use self::syntax_error::{SyntaxError, SyntaxErrorKind, Location}; pub use rowan::{TreeRoot, WalkEvent}; #[derive(Debug, Clone, Copy)] pub enum RaTypes {} impl Types for RaTypes { type Kind = SyntaxKind; type RootData = Vec; } pub type OwnedRoot = ::rowan::OwnedRoot; pub type RefRoot<'a> = ::rowan::RefRoot<'a, RaTypes>; pub type GreenNode = ::rowan::GreenNode; #[derive(Clone, Copy)] pub struct SyntaxNode = OwnedRoot>(::rowan::SyntaxNode); pub type SyntaxNodeRef<'a> = SyntaxNode>; impl PartialEq> for SyntaxNode where R1: TreeRoot, R2: TreeRoot, { fn eq(&self, other: &SyntaxNode) -> bool { self.0 == other.0 } } impl> Eq for SyntaxNode {} impl> Hash for SyntaxNode { fn hash(&self, state: &mut H) { self.0.hash(state) } } impl SyntaxNode { pub(crate) fn new(green: GreenNode, errors: Vec) -> SyntaxNode { SyntaxNode(::rowan::SyntaxNode::new(green, errors)) } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Direction { Next, Prev, } impl<'a> SyntaxNodeRef<'a> { pub fn leaf_text(self) -> Option<&'a SmolStr> { self.0.leaf_text() } pub fn ancestors(self) -> impl Iterator> { crate::algo::generate(Some(self), |&node| node.parent()) } pub fn descendants(self) -> impl Iterator> { self.preorder().filter_map(|event| match event { WalkEvent::Enter(node) => Some(node), WalkEvent::Leave(_) => None, }) } pub fn siblings(self, direction: Direction) -> impl Iterator> { crate::algo::generate(Some(self), move |&node| match direction { Direction::Next => node.next_sibling(), Direction::Prev => node.prev_sibling(), }) } pub fn preorder(self) -> impl Iterator>> { self.0.preorder().map(|event| match event { WalkEvent::Enter(n) => WalkEvent::Enter(SyntaxNode(n)), WalkEvent::Leave(n) => WalkEvent::Leave(SyntaxNode(n)), }) } } impl> SyntaxNode { pub(crate) fn root_data(&self) -> &Vec { self.0.root_data() } pub(crate) fn replace_with(&self, replacement: GreenNode) -> GreenNode { self.0.replace_with(replacement) } pub fn borrowed<'a>(&'a self) -> SyntaxNode> { SyntaxNode(self.0.borrowed()) } pub fn owned(&self) -> SyntaxNode { SyntaxNode(self.0.owned()) } pub fn kind(&self) -> SyntaxKind { self.0.kind() } pub fn range(&self) -> TextRange { self.0.range() } pub fn text(&self) -> SyntaxText { SyntaxText::new(self.borrowed()) } pub fn is_leaf(&self) -> bool { self.0.is_leaf() } pub fn parent(&self) -> Option> { self.0.parent().map(SyntaxNode) } pub fn first_child(&self) -> Option> { self.0.first_child().map(SyntaxNode) } pub fn last_child(&self) -> Option> { self.0.last_child().map(SyntaxNode) } pub fn next_sibling(&self) -> Option> { self.0.next_sibling().map(SyntaxNode) } pub fn prev_sibling(&self) -> Option> { self.0.prev_sibling().map(SyntaxNode) } pub fn children(&self) -> SyntaxNodeChildren { SyntaxNodeChildren(self.0.children()) } } impl> fmt::Debug for SyntaxNode { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "{:?}@{:?}", self.kind(), self.range())?; if has_short_text(self.kind()) { write!(fmt, " \"{}\"", self.text())?; } Ok(()) } } #[derive(Debug)] pub struct SyntaxNodeChildren>(::rowan::SyntaxNodeChildren); impl> Iterator for SyntaxNodeChildren { type Item = SyntaxNode; fn next(&mut self) -> Option> { self.0.next().map(SyntaxNode) } } fn has_short_text(kind: SyntaxKind) -> bool { use crate::SyntaxKind::*; match kind { IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true, _ => false, } }