1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
//! Primitive tree editor, ed for trees
use std::ops::RangeInclusive;
use parser::T;
use crate::{ast::make, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken};
#[derive(Debug)]
pub struct Position {
repr: PositionRepr,
}
#[derive(Debug)]
enum PositionRepr {
FirstChild(SyntaxNode),
After(SyntaxElement),
}
impl Position {
pub fn after(elem: impl Into<SyntaxElement>) -> Position {
let repr = PositionRepr::After(elem.into());
Position { repr }
}
pub fn before(elem: impl Into<SyntaxElement>) -> Position {
let elem = elem.into();
let repr = match elem.prev_sibling_or_token() {
Some(it) => PositionRepr::After(it),
None => PositionRepr::FirstChild(elem.parent().unwrap()),
};
Position { repr }
}
pub fn first_child_of(node: impl Into<SyntaxNode>) -> Position {
let repr = PositionRepr::FirstChild(node.into());
Position { repr }
}
pub fn last_child_of(node: impl Into<SyntaxNode>) -> Position {
let node = node.into();
let repr = match node.last_child_or_token() {
Some(it) => PositionRepr::After(it),
None => PositionRepr::FirstChild(node),
};
Position { repr }
}
}
pub fn insert_ws(position: Position, elem: impl Into<SyntaxElement>) {
insert_all_ws(position, vec![elem.into()])
}
pub fn insert(position: Position, elem: impl Into<SyntaxElement>) {
insert_all(position, vec![elem.into()])
}
pub fn insert_all_ws(position: Position, mut elements: Vec<SyntaxElement>) {
if let Some(first) = elements.first() {
if let Some(ws) = ws_before(&position, first) {
elements.insert(0, ws.into())
}
}
if let Some(last) = elements.last() {
if let Some(ws) = ws_after(&position, last) {
elements.push(ws.into())
}
}
insert_all(position, elements)
}
pub fn insert_all(position: Position, elements: Vec<SyntaxElement>) {
let (parent, index) = match position.repr {
PositionRepr::FirstChild(parent) => (parent, 0),
PositionRepr::After(child) => (child.parent().unwrap(), child.index() + 1),
};
parent.splice_children(index..index, elements);
}
pub fn remove(elem: impl Into<SyntaxElement>) {
let elem = elem.into();
remove_all(elem.clone()..=elem)
}
pub fn remove_all(range: RangeInclusive<SyntaxElement>) {
replace_all(range, Vec::new())
}
pub fn replace(old: impl Into<SyntaxElement>, new: impl Into<SyntaxElement>) {
let old = old.into();
replace_all(old.clone()..=old, vec![new.into()])
}
pub fn replace_all(range: RangeInclusive<SyntaxElement>, new: Vec<SyntaxElement>) {
let start = range.start().index();
let end = range.end().index();
let parent = range.start().parent().unwrap();
parent.splice_children(start..end + 1, new)
}
pub fn append_child_ws(node: impl Into<SyntaxNode>, child: impl Into<SyntaxElement>) {
let position = Position::last_child_of(node);
insert_ws(position, child)
}
pub fn append_child(node: impl Into<SyntaxNode>, child: impl Into<SyntaxElement>) {
let position = Position::last_child_of(node);
insert(position, child)
}
fn ws_before(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {
let prev = match &position.repr {
PositionRepr::FirstChild(_) => return None,
PositionRepr::After(it) => it,
};
ws_between(prev, new)
}
fn ws_after(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {
let next = match &position.repr {
PositionRepr::FirstChild(parent) => parent.first_child_or_token()?,
PositionRepr::After(sibling) => sibling.next_sibling_or_token()?,
};
ws_between(new, &next)
}
fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken> {
if left.kind() == SyntaxKind::WHITESPACE || right.kind() == SyntaxKind::WHITESPACE {
return None;
}
if right.kind() == T![;] || right.kind() == T![,] {
return None;
}
Some(make::tokens::single_space().into())
}
|
