555 lines
17 KiB
Rust
555 lines
17 KiB
Rust
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))
|
|
}
|
|
pub fn new_root_mut(green: GreenNode) -> SyntaxNode<L> {
|
|
SyntaxNode::from(cursor::SyntaxNode::new_root_mut(green))
|
|
}
|
|
|
|
/// Returns a green tree, equal to the green tree this node
|
|
/// belongs to, except with this node substituted. The complexity
|
|
/// of the 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 first_child_by_kind(&self, matcher: &impl Fn(L::Kind) -> bool) -> Option<SyntaxNode<L>> {
|
|
self.raw
|
|
.first_child_by_kind(&|raw_kind| matcher(L::kind_from_raw(raw_kind)))
|
|
.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 first_child_or_token_by_kind(
|
|
&self,
|
|
matcher: &impl Fn(L::Kind) -> bool,
|
|
) -> Option<SyntaxElement<L>> {
|
|
self.raw
|
|
.first_child_or_token_by_kind(&|raw_kind| matcher(L::kind_from_raw(raw_kind)))
|
|
.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 next_sibling_by_kind(
|
|
&self,
|
|
matcher: &impl Fn(L::Kind) -> bool,
|
|
) -> Option<SyntaxNode<L>> {
|
|
self.raw
|
|
.next_sibling_by_kind(&|raw_kind| matcher(L::kind_from_raw(raw_kind)))
|
|
.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 next_sibling_or_token_by_kind(
|
|
&self,
|
|
matcher: &impl Fn(L::Kind) -> bool,
|
|
) -> Option<SyntaxElement<L>> {
|
|
self.raw
|
|
.next_sibling_or_token_by_kind(&|raw_kind| matcher(L::kind_from_raw(raw_kind)))
|
|
.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 within 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
|
|
/// within 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 is_mutable(&self) -> bool {
|
|
self.raw.is_mutable()
|
|
}
|
|
|
|
pub fn detach(&self) {
|
|
self.raw.detach()
|
|
}
|
|
|
|
pub fn splice_children<I: IntoIterator<Item = SyntaxElement<L>>>(
|
|
&self,
|
|
to_delete: Range<usize>,
|
|
to_insert: I,
|
|
) {
|
|
let to_insert = to_insert.into_iter().map(cursor::SyntaxElement::from);
|
|
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 to, except with this token substituted. The complexity
|
|
/// of the 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)
|
|
}
|
|
}
|
|
|
|
impl<L: Language> SyntaxNodeChildren<L> {
|
|
pub fn by_kind(self, matcher: impl Fn(L::Kind) -> bool) -> impl Iterator<Item = SyntaxNode<L>> {
|
|
self.raw
|
|
.by_kind(move |raw_kind| matcher(L::kind_from_raw(raw_kind)))
|
|
.into_iter()
|
|
.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)
|
|
}
|
|
}
|
|
|
|
impl<L: Language> SyntaxElementChildren<L> {
|
|
pub fn by_kind(
|
|
self,
|
|
matcher: impl Fn(L::Kind) -> bool,
|
|
) -> impl Iterator<Item = SyntaxElement<L>> {
|
|
self.raw.by_kind(move |raw_kind| matcher(L::kind_from_raw(raw_kind))).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()),
|
|
}
|
|
}
|
|
}
|