bytebraise_syntax/syntax/
ted.rs1use crate::syntax::syntax_node::{SyntaxElement, SyntaxNode, SyntaxToken};
9use std::{mem, ops::RangeInclusive};
10
11pub trait Element {
14 fn syntax_element(self) -> SyntaxElement;
15}
16
17impl<E: Element + Clone> Element for &'_ E {
18 fn syntax_element(self) -> SyntaxElement {
19 self.clone().syntax_element()
20 }
21}
22impl Element for SyntaxElement {
23 fn syntax_element(self) -> SyntaxElement {
24 self
25 }
26}
27impl Element for SyntaxNode {
28 fn syntax_element(self) -> SyntaxElement {
29 self.into()
30 }
31}
32impl Element for SyntaxToken {
33 fn syntax_element(self) -> SyntaxElement {
34 self.into()
35 }
36}
37
38#[derive(Debug)]
39pub struct Position {
40 repr: PositionRepr,
41}
42
43#[derive(Debug)]
44enum PositionRepr {
45 FirstChild(SyntaxNode),
46 After(SyntaxElement),
47}
48
49impl Position {
50 pub fn after(elem: impl Element) -> Position {
51 let repr = PositionRepr::After(elem.syntax_element());
52 Position { repr }
53 }
54 pub fn before(elem: impl Element) -> Position {
55 let elem = elem.syntax_element();
56 let repr = match elem.prev_sibling_or_token() {
57 Some(it) => PositionRepr::After(it),
58 None => PositionRepr::FirstChild(elem.parent().unwrap()),
59 };
60 Position { repr }
61 }
62 pub fn first_child_of(node: &(impl Into<SyntaxNode> + Clone)) -> Position {
63 let repr = PositionRepr::FirstChild(node.clone().into());
64 Position { repr }
65 }
66 pub fn last_child_of(node: &(impl Into<SyntaxNode> + Clone)) -> Position {
67 let node = node.clone().into();
68 let repr = match node.last_child_or_token() {
69 Some(it) => PositionRepr::After(it),
70 None => PositionRepr::FirstChild(node),
71 };
72 Position { repr }
73 }
74}
75
76pub fn insert(position: Position, elem: impl Element) {
77 insert_all(position, vec![elem.syntax_element()]);
78}
79pub fn insert_raw(position: Position, elem: impl Element) {
80 insert_all_raw(position, vec![elem.syntax_element()]);
81}
82pub fn insert_all(position: Position, elements: Vec<SyntaxElement>) {
83 insert_all_raw(position, elements);
95}
96pub fn insert_all_raw(position: Position, elements: Vec<SyntaxElement>) {
97 let (parent, index) = match position.repr {
98 PositionRepr::FirstChild(parent) => (parent, 0),
99 PositionRepr::After(child) => (child.parent().unwrap(), child.index() + 1),
100 };
101 parent.splice_children(index..index, elements);
102}
103
104pub fn remove(elem: impl Element) {
105 elem.syntax_element().detach();
106}
107pub fn remove_all(range: RangeInclusive<SyntaxElement>) {
108 replace_all(range, Vec::new());
109}
110pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
111 let mut it = range.into_iter();
112 if let Some(mut first) = it.next() {
113 match it.last() {
114 Some(mut last) => {
115 if first.index() > last.index() {
116 mem::swap(&mut first, &mut last);
117 }
118 remove_all(first..=last);
119 }
120 None => remove(first),
121 }
122 }
123}
124
125pub fn replace(old: impl Element, new: impl Element) {
126 replace_with_many(old, vec![new.syntax_element()]);
127}
128pub fn replace_with_many(old: impl Element, new: Vec<SyntaxElement>) {
129 let old = old.syntax_element();
130 replace_all(old.clone()..=old, new);
131}
132pub fn replace_all(range: RangeInclusive<SyntaxElement>, new: Vec<SyntaxElement>) {
133 let start = range.start().index();
134 let end = range.end().index();
135 let parent = range.start().parent().unwrap();
136 parent.splice_children(start..end + 1, new);
137}
138
139pub fn append_child(node: &(impl Into<SyntaxNode> + Clone), child: impl Element) {
140 let position = Position::last_child_of(node);
141 insert(position, child);
142}
143pub fn append_child_raw(node: &(impl Into<SyntaxNode> + Clone), child: impl Element) {
144 let position = Position::last_child_of(node);
145 insert_raw(position, child);
146}
147
148