use std::{borrow::Cow, fmt, iter, marker::PhantomData, ops::Range}; use crate::{ cursor, green::GreenTokenData, Direction, GreenNode, GreenNodeData, GreenToken, NodeOrToken, SyntaxKind, SyntaxText, TextRange, TextSize, TokenAtOffset, WalkEvent, }; pub trait Language: Sized + Copy + fmt::Debug + Eq + Ord + std::hash::Hash { type Kind: Sized + Copy + fmt::Debug + Eq + Ord + std::hash::Hash; fn kind_from_raw(raw: SyntaxKind) -> Self::Kind; fn kind_to_raw(kind: Self::Kind) -> SyntaxKind; } #[derive(Clone, PartialEq, Eq, Hash)] pub struct SyntaxNode<L: Language> { raw: cursor::SyntaxNode, _p: PhantomData<L>, } #[derive(Clone, PartialEq, Eq, Hash)] pub struct SyntaxToken<L: Language> { raw: cursor::SyntaxToken, _p: PhantomData<L>, } pub type SyntaxElement<L> = NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>; impl<L: Language> fmt::Debug for SyntaxNode<L> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if f.alternate() { let mut level = 0; for event in self.preorder_with_tokens() { match event { WalkEvent::Enter(element) => { for _ in 0..level { write!(f, " ")?; } match element { NodeOrToken::Node(node) => writeln!(f, "{:?}", node)?, NodeOrToken::Token(token) => writeln!(f, "{:?}", token)?, } level += 1; } WalkEvent::Leave(_) => level -= 1, } } assert_eq!(level, 0); Ok(()) } else { write!(f, "{:?}@{:?}", self.kind(), self.text_range()) } } } impl<L: Language> fmt::Display for SyntaxNode<L> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.raw, f) } } impl<L: Language> fmt::Debug for SyntaxToken<L> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?}@{:?}", self.kind(), self.text_range())?; if self.text().len() < 25 { return write!(f, " {:?}", self.text()); } let text = self.text(); for idx in 21..25 { if text.is_char_boundary(idx) { let text = format!("{} ...", &text[..idx]); return write!(f, " {:?}", text); } } unreachable!() } } impl<L: Language> fmt::Display for SyntaxToken<L> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.raw, f) } } impl<L: Language> From<SyntaxNode<L>> for SyntaxElement<L> { fn from(node: SyntaxNode<L>) -> SyntaxElement<L> { NodeOrToken::Node(node) } } impl<L: Language> From<SyntaxToken<L>> for SyntaxElement<L> { fn from(token: SyntaxToken<L>) -> SyntaxElement<L> { NodeOrToken::Token(token) } } impl<L: Language> SyntaxNode<L> { pub fn new_root(green: GreenNode) -> SyntaxNode<L> { SyntaxNode::from(cursor::SyntaxNode::new_root(green)) } /// Returns a green tree, equal to the green tree this node /// belongs two, except with this node substitute. The complexity /// of operation is proportional to the depth of the tree pub fn replace_with(&self, replacement: GreenNode) -> GreenNode { self.raw.replace_with(replacement) } pub fn kind(&self) -> L::Kind { L::kind_from_raw(self.raw.kind()) } pub fn text_range(&self) -> TextRange { self.raw.text_range() } pub fn index(&self) -> usize { self.raw.index() } pub fn text(&self) -> SyntaxText { self.raw.text() } pub fn green(&self) -> Cow<'_, GreenNodeData> { self.raw.green() } pub fn parent(&self) -> Option<SyntaxNode<L>> { self.raw.parent().map(Self::from) } pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode<L>> { self.raw.ancestors().map(SyntaxNode::from) } pub fn children(&self) -> SyntaxNodeChildren<L> { SyntaxNodeChildren { raw: self.raw.children(), _p: PhantomData } } pub fn children_with_tokens(&self) -> SyntaxElementChildren<L> { SyntaxElementChildren { raw: self.raw.children_with_tokens(), _p: PhantomData } } pub fn first_child(&self) -> Option<SyntaxNode<L>> { self.raw.first_child().map(Self::from) } pub fn last_child(&self) -> Option<SyntaxNode<L>> { self.raw.last_child().map(Self::from) } pub fn first_child_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.first_child_or_token().map(NodeOrToken::from) } pub fn last_child_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.last_child_or_token().map(NodeOrToken::from) } pub fn next_sibling(&self) -> Option<SyntaxNode<L>> { self.raw.next_sibling().map(Self::from) } pub fn prev_sibling(&self) -> Option<SyntaxNode<L>> { self.raw.prev_sibling().map(Self::from) } pub fn next_sibling_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.next_sibling_or_token().map(NodeOrToken::from) } pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.prev_sibling_or_token().map(NodeOrToken::from) } /// Return the leftmost token in the subtree of this node. pub fn first_token(&self) -> Option<SyntaxToken<L>> { self.raw.first_token().map(SyntaxToken::from) } /// Return the rightmost token in the subtree of this node. pub fn last_token(&self) -> Option<SyntaxToken<L>> { self.raw.last_token().map(SyntaxToken::from) } pub fn siblings(&self, direction: Direction) -> impl Iterator<Item = SyntaxNode<L>> { self.raw.siblings(direction).map(SyntaxNode::from) } pub fn siblings_with_tokens( &self, direction: Direction, ) -> impl Iterator<Item = SyntaxElement<L>> { self.raw.siblings_with_tokens(direction).map(SyntaxElement::from) } pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode<L>> { self.raw.descendants().map(SyntaxNode::from) } pub fn descendants_with_tokens(&self) -> impl Iterator<Item = SyntaxElement<L>> { self.raw.descendants_with_tokens().map(NodeOrToken::from) } /// Traverse the subtree rooted at the current node (including the current /// node) in preorder, excluding tokens. pub fn preorder(&self) -> Preorder<L> { Preorder { raw: self.raw.preorder(), _p: PhantomData } } /// Traverse the subtree rooted at the current node (including the current /// node) in preorder, including tokens. pub fn preorder_with_tokens(&self) -> PreorderWithTokens<L> { PreorderWithTokens { raw: self.raw.preorder_with_tokens(), _p: PhantomData } } /// Find a token in the subtree corresponding to this node, which covers the offset. /// Precondition: offset must be withing node's range. pub fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken<L>> { self.raw.token_at_offset(offset).map(SyntaxToken::from) } /// Return the deepest node or token in the current subtree that fully /// contains the range. If the range is empty and is contained in two leaf /// nodes, either one can be returned. Precondition: range must be contained /// withing the current node pub fn covering_element(&self, range: TextRange) -> SyntaxElement<L> { NodeOrToken::from(self.raw.covering_element(range)) } /// Finds a [`SyntaxElement`] which intersects with a given `range`. If /// there are several intersecting elements, any one can be returned. /// /// The method uses binary search internally, so it's complexity is /// `O(log(N))` where `N = self.children_with_tokens().count()`. pub fn child_or_token_at_range(&self, range: TextRange) -> Option<SyntaxElement<L>> { self.raw.child_or_token_at_range(range).map(SyntaxElement::from) } /// Returns an independent copy of the subtree rooted at this node. /// /// The parent of the returned node will be `None`, the start offset will be /// zero, but, otherwise, it'll be equivalent to the source node. pub fn clone_subtree(&self) -> SyntaxNode<L> { SyntaxNode::from(self.raw.clone_subtree()) } pub fn clone_for_update(&self) -> SyntaxNode<L> { SyntaxNode::from(self.raw.clone_for_update()) } pub fn detach(&self) { self.raw.detach() } pub fn splice_children(&self, to_delete: Range<usize>, to_insert: Vec<SyntaxElement<L>>) { let to_insert = to_insert.into_iter().map(cursor::SyntaxElement::from).collect::<Vec<_>>(); self.raw.splice_children(to_delete, to_insert) } } impl<L: Language> SyntaxToken<L> { /// Returns a green tree, equal to the green tree this token /// belongs two, except with this token substitute. The complexity /// of operation is proportional to the depth of the tree pub fn replace_with(&self, new_token: GreenToken) -> GreenNode { self.raw.replace_with(new_token) } pub fn kind(&self) -> L::Kind { L::kind_from_raw(self.raw.kind()) } pub fn text_range(&self) -> TextRange { self.raw.text_range() } pub fn index(&self) -> usize { self.raw.index() } pub fn text(&self) -> &str { self.raw.text() } pub fn green(&self) -> &GreenTokenData { self.raw.green() } pub fn parent(&self) -> Option<SyntaxNode<L>> { self.raw.parent().map(SyntaxNode::from) } /// Iterator over all the ancestors of this token excluding itself. #[deprecated = "use `SyntaxToken::parent_ancestors` instead"] pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode<L>> { self.parent_ancestors() } /// Iterator over all the ancestors of this token excluding itself. pub fn parent_ancestors(&self) -> impl Iterator<Item = SyntaxNode<L>> { self.raw.ancestors().map(SyntaxNode::from) } pub fn next_sibling_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.next_sibling_or_token().map(NodeOrToken::from) } pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement<L>> { self.raw.prev_sibling_or_token().map(NodeOrToken::from) } pub fn siblings_with_tokens( &self, direction: Direction, ) -> impl Iterator<Item = SyntaxElement<L>> { self.raw.siblings_with_tokens(direction).map(SyntaxElement::from) } /// Next token in the tree (i.e, not necessary a sibling). pub fn next_token(&self) -> Option<SyntaxToken<L>> { self.raw.next_token().map(SyntaxToken::from) } /// Previous token in the tree (i.e, not necessary a sibling). pub fn prev_token(&self) -> Option<SyntaxToken<L>> { self.raw.prev_token().map(SyntaxToken::from) } pub fn detach(&self) { self.raw.detach() } } impl<L: Language> SyntaxElement<L> { pub fn text_range(&self) -> TextRange { match self { NodeOrToken::Node(it) => it.text_range(), NodeOrToken::Token(it) => it.text_range(), } } pub fn index(&self) -> usize { match self { NodeOrToken::Node(it) => it.index(), NodeOrToken::Token(it) => it.index(), } } pub fn kind(&self) -> L::Kind { match self { NodeOrToken::Node(it) => it.kind(), NodeOrToken::Token(it) => it.kind(), } } pub fn parent(&self) -> Option<SyntaxNode<L>> { match self { NodeOrToken::Node(it) => it.parent(), NodeOrToken::Token(it) => it.parent(), } } pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode<L>> { let first = match self { NodeOrToken::Node(it) => Some(it.clone()), NodeOrToken::Token(it) => it.parent(), }; iter::successors(first, SyntaxNode::parent) } pub fn next_sibling_or_token(&self) -> Option<SyntaxElement<L>> { match self { NodeOrToken::Node(it) => it.next_sibling_or_token(), NodeOrToken::Token(it) => it.next_sibling_or_token(), } } pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement<L>> { match self { NodeOrToken::Node(it) => it.prev_sibling_or_token(), NodeOrToken::Token(it) => it.prev_sibling_or_token(), } } pub fn detach(&self) { match self { NodeOrToken::Node(it) => it.detach(), NodeOrToken::Token(it) => it.detach(), } } } #[derive(Debug, Clone)] pub struct SyntaxNodeChildren<L: Language> { raw: cursor::SyntaxNodeChildren, _p: PhantomData<L>, } impl<L: Language> Iterator for SyntaxNodeChildren<L> { type Item = SyntaxNode<L>; fn next(&mut self) -> Option<Self::Item> { self.raw.next().map(SyntaxNode::from) } } #[derive(Debug, Clone)] pub struct SyntaxElementChildren<L: Language> { raw: cursor::SyntaxElementChildren, _p: PhantomData<L>, } impl<L: Language> Iterator for SyntaxElementChildren<L> { type Item = SyntaxElement<L>; fn next(&mut self) -> Option<Self::Item> { self.raw.next().map(NodeOrToken::from) } } pub struct Preorder<L: Language> { raw: cursor::Preorder, _p: PhantomData<L>, } impl<L: Language> Preorder<L> { pub fn skip_subtree(&mut self) { self.raw.skip_subtree() } } impl<L: Language> Iterator for Preorder<L> { type Item = WalkEvent<SyntaxNode<L>>; fn next(&mut self) -> Option<Self::Item> { self.raw.next().map(|it| it.map(SyntaxNode::from)) } } pub struct PreorderWithTokens<L: Language> { raw: cursor::PreorderWithTokens, _p: PhantomData<L>, } impl<L: Language> PreorderWithTokens<L> { pub fn skip_subtree(&mut self) { self.raw.skip_subtree() } } impl<L: Language> Iterator for PreorderWithTokens<L> { type Item = WalkEvent<SyntaxElement<L>>; fn next(&mut self) -> Option<Self::Item> { self.raw.next().map(|it| it.map(SyntaxElement::from)) } } impl<L: Language> From<cursor::SyntaxNode> for SyntaxNode<L> { fn from(raw: cursor::SyntaxNode) -> SyntaxNode<L> { SyntaxNode { raw, _p: PhantomData } } } impl<L: Language> From<SyntaxNode<L>> for cursor::SyntaxNode { fn from(node: SyntaxNode<L>) -> cursor::SyntaxNode { node.raw } } impl<L: Language> From<cursor::SyntaxToken> for SyntaxToken<L> { fn from(raw: cursor::SyntaxToken) -> SyntaxToken<L> { SyntaxToken { raw, _p: PhantomData } } } impl<L: Language> From<SyntaxToken<L>> for cursor::SyntaxToken { fn from(token: SyntaxToken<L>) -> cursor::SyntaxToken { token.raw } } impl<L: Language> From<cursor::SyntaxElement> for SyntaxElement<L> { fn from(raw: cursor::SyntaxElement) -> SyntaxElement<L> { match raw { NodeOrToken::Node(it) => NodeOrToken::Node(it.into()), NodeOrToken::Token(it) => NodeOrToken::Token(it.into()), } } } impl<L: Language> From<SyntaxElement<L>> for cursor::SyntaxElement { fn from(element: SyntaxElement<L>) -> cursor::SyntaxElement { match element { NodeOrToken::Node(it) => NodeOrToken::Node(it.into()), NodeOrToken::Token(it) => NodeOrToken::Token(it.into()), } } }