mod builder; pub mod syntax_error; mod syntax_text; use std::{fmt, borrow::Borrow}; use self::syntax_text::SyntaxText; use crate::{SmolStr, SyntaxKind, TextRange}; use rowan::{Types, TransparentNewType}; pub(crate) use self::builder::GreenBuilder; pub use self::syntax_error::{SyntaxError, SyntaxErrorKind, Location}; pub use rowan::WalkEvent; #[derive(Debug, Clone, Copy)] pub enum RaTypes {} impl Types for RaTypes { type Kind = SyntaxKind; type RootData = Vec; } pub type GreenNode = rowan::GreenNode; #[derive(PartialEq, Eq, Hash)] pub struct TreeArc>>( pub(crate) rowan::TreeArc, ); impl>> Borrow for TreeArc { fn borrow(&self) -> &T { &*self } } impl TreeArc where T: TransparentNewType>, { pub(crate) fn cast(this: TreeArc) -> TreeArc where U: TransparentNewType>, { TreeArc(rowan::TreeArc::cast(this.0)) } } impl std::ops::Deref for TreeArc where T: TransparentNewType>, { type Target = T; fn deref(&self) -> &T { self.0.deref() } } impl PartialEq for TreeArc where T: TransparentNewType>, T: PartialEq, { fn eq(&self, other: &T) -> bool { let t: &T = self; t == other } } impl Clone for TreeArc where T: TransparentNewType>, { fn clone(&self) -> TreeArc { TreeArc(self.0.clone()) } } impl fmt::Debug for TreeArc where T: TransparentNewType>, T: fmt::Debug, { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&self.0, fmt) } } #[derive(PartialEq, Eq, Hash)] #[repr(transparent)] pub struct SyntaxNode(pub(crate) rowan::SyntaxNode); unsafe impl TransparentNewType for SyntaxNode { type Repr = rowan::SyntaxNode; } impl SyntaxNode { pub(crate) fn new(green: GreenNode, errors: Vec) -> TreeArc { let ptr = TreeArc(rowan::SyntaxNode::new(green, errors)); TreeArc::cast(ptr) } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Direction { Next, Prev, } impl SyntaxNode { pub fn leaf_text(&self) -> Option<&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::from_repr(n)), WalkEvent::Leave(n) => WalkEvent::Leave(SyntaxNode::from_repr(n)), }) } } impl ToOwned for SyntaxNode { type Owned = TreeArc; fn to_owned(&self) -> TreeArc { let ptr = TreeArc(self.0.to_owned()); TreeArc::cast(ptr) } } 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_self(replacement) } pub fn kind(&self) -> SyntaxKind { self.0.kind() } pub fn range(&self) -> TextRange { self.0.range() } pub fn text(&self) -> SyntaxText { SyntaxText::new(self) } pub fn is_leaf(&self) -> bool { self.0.is_leaf() } pub fn parent(&self) -> Option<&SyntaxNode> { self.0.parent().map(SyntaxNode::from_repr) } pub fn first_child(&self) -> Option<&SyntaxNode> { self.0.first_child().map(SyntaxNode::from_repr) } pub fn last_child(&self) -> Option<&SyntaxNode> { self.0.last_child().map(SyntaxNode::from_repr) } pub fn next_sibling(&self) -> Option<&SyntaxNode> { self.0.next_sibling().map(SyntaxNode::from_repr) } pub fn prev_sibling(&self) -> Option<&SyntaxNode> { self.0.prev_sibling().map(SyntaxNode::from_repr) } pub fn children(&self) -> SyntaxNodeChildren { SyntaxNodeChildren(self.0.children()) } pub fn memory_size_of_subtree(&self) -> usize { self.0.memory_size_of_subtree() } } 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<'a>(rowan::SyntaxNodeChildren<'a, RaTypes>); impl<'a> Iterator for SyntaxNodeChildren<'a> { type Item = &'a SyntaxNode; fn next(&mut self) -> Option<&'a SyntaxNode> { self.0.next().map(SyntaxNode::from_repr) } } fn has_short_text(kind: SyntaxKind) -> bool { use crate::SyntaxKind::*; match kind { IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true, _ => false, } }