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
|
use libsyntax2::{
TextUnit, TextRange, SyntaxNodeRef,
ast,
algo::{
walk::preorder,
find_covering_node,
},
SyntaxKind::*,
};
use {ActionResult, EditBuilder};
pub fn join_lines(file: &ast::ParsedFile, range: TextRange) -> ActionResult {
let range = if range.is_empty() {
let text = file.syntax().text();
let text = &text[TextRange::from_to(range.start(), TextUnit::of_str(&text))];
let pos = text.bytes().take_while(|&b| b != b'\n').count();
if pos == text.len() {
return ActionResult {
edit: EditBuilder::new().finish(),
cursor_position: None
};
}
let pos: TextUnit = (pos as u32).into();
TextRange::offset_len(
range.start() + pos,
TextUnit::of_char('\n'),
)
} else {
range
};
let node = find_covering_node(file.syntax(), range);
let mut edit = EditBuilder::new();
for node in preorder(node) {
let text = match node.leaf_text() {
Some(text) => text,
None => continue,
};
let range = match intersect(range, node.range()) {
Some(range) => range,
None => continue,
} - node.range().start();
for (pos, _) in text[range].bytes().enumerate().filter(|&(_, b)| b == b'\n') {
let pos: TextUnit = (pos as u32).into();
let off = node.range().start() + range.start() + pos;
remove_newline(&mut edit, node, text.as_str(), off);
}
}
ActionResult {
edit: edit.finish(),
cursor_position: None,
}
}
fn intersect(r1: TextRange, r2: TextRange) -> Option<TextRange> {
let start = r1.start().max(r2.start());
let end = r1.end().min(r2.end());
if start <= end {
Some(TextRange::from_to(start, end))
} else {
None
}
}
fn remove_newline(
edit: &mut EditBuilder,
node: SyntaxNodeRef,
node_text: &str,
offset: TextUnit,
) {
if node.kind() == WHITESPACE && node_text.bytes().filter(|&b| b == b'\n').count() == 1 {
match (node.prev_sibling(), node.next_sibling()) {
(Some(prev), Some(next)) => {
let range = TextRange::from_to(prev.range().start(), node.range().end());
if prev.kind() == COMMA && (next.kind() == R_PAREN || next.kind() == R_BRACK) {
edit.delete(range);
} else if prev.kind() == COMMA && next.kind() == R_CURLY {
edit.replace(range, " ".to_string());
} else {
edit.replace(
node.range(),
compute_ws(prev, next).to_string(),
);
}
return;
}
_ => (),
}
}
let suff = &node_text[TextRange::from_to(
offset - node.range().start() + TextUnit::of_char('\n'),
TextUnit::of_str(node_text),
)];
let spaces = suff.bytes().take_while(|&b| b == b' ').count();
edit.replace(
TextRange::offset_len(offset, ((spaces + 1) as u32).into()),
" ".to_string(),
);
}
fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
match left.kind() {
L_PAREN | L_BRACK => return "",
_ => (),
}
match right.kind() {
R_PAREN | R_BRACK => return "",
_ => (),
}
" "
}
|
