rust/crates/ra_ide_api/src/join_lines.rs

583 lines
12 KiB
Rust
Raw Normal View History

2019-01-10 08:50:49 -06:00
use itertools::Itertools;
use ra_syntax::{
2019-04-02 02:23:18 -05:00
SourceFile, TextRange, TextUnit, SyntaxNode, SyntaxElement, SyntaxToken,
2019-01-10 09:32:02 -06:00
SyntaxKind::{self, WHITESPACE, COMMA, R_CURLY, R_PAREN, R_BRACK},
2019-03-30 05:25:53 -05:00
algo::{find_covering_element, non_trivia_sibling},
2019-04-02 02:23:18 -05:00
ast::{self, AstNode, AstToken},
Direction,
2019-01-10 08:50:49 -06:00
};
use ra_fmt::{
compute_ws, extract_trivial_expression
};
2019-03-21 15:42:22 -05:00
use ra_text_edit::{TextEdit, TextEditBuilder};
2019-01-10 08:50:49 -06:00
2019-03-22 11:10:20 -05:00
pub fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
let range = if range.is_empty() {
2019-01-10 08:50:49 -06:00
let syntax = file.syntax();
2019-03-22 11:10:20 -05:00
let text = syntax.text().slice(range.start()..);
2019-01-10 08:50:49 -06:00
let pos = match text.find('\n') {
2019-03-21 15:42:22 -05:00
None => return TextEditBuilder::default().finish(),
2019-01-10 08:50:49 -06:00
Some(pos) => pos,
};
2019-03-22 11:10:20 -05:00
TextRange::offset_len(range.start() + pos, TextUnit::of_char('\n'))
2019-01-10 08:50:49 -06:00
} else {
2019-03-22 11:10:20 -05:00
range
2019-01-10 08:50:49 -06:00
};
2019-03-30 05:25:53 -05:00
let node = match find_covering_element(file.syntax(), range) {
SyntaxElement::Node(node) => node,
SyntaxElement::Token(token) => token.parent(),
};
2019-01-10 08:50:49 -06:00
let mut edit = TextEditBuilder::default();
2019-03-30 05:25:53 -05:00
for token in node.descendants_with_tokens().filter_map(|it| it.as_token()) {
let range = match range.intersection(&token.range()) {
2019-01-10 08:50:49 -06:00
Some(range) => range,
None => continue,
2019-03-30 05:25:53 -05:00
} - token.range().start();
let text = token.text();
2019-01-10 08:50:49 -06:00
for (pos, _) in text[range].bytes().enumerate().filter(|&(_, b)| b == b'\n') {
let pos: TextUnit = (pos as u32).into();
2019-03-30 05:25:53 -05:00
let off = token.range().start() + range.start() + pos;
2019-01-10 08:50:49 -06:00
if !edit.invalidates_offset(off) {
2019-03-30 05:25:53 -05:00
remove_newline(&mut edit, token, off);
2019-01-10 08:50:49 -06:00
}
}
}
2019-03-21 15:42:22 -05:00
edit.finish()
2019-01-10 08:50:49 -06:00
}
2019-03-30 05:25:53 -05:00
fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUnit) {
if token.kind() != WHITESPACE || token.text().bytes().filter(|&b| b == b'\n').count() != 1 {
2019-01-10 08:50:49 -06:00
// The node is either the first or the last in the file
2019-03-30 05:25:53 -05:00
let suff = &token.text()[TextRange::from_to(
offset - token.range().start() + TextUnit::of_char('\n'),
TextUnit::of_str(token.text()),
2019-01-10 08:50:49 -06:00
)];
let spaces = suff.bytes().take_while(|&b| b == b' ').count();
2019-02-08 05:49:43 -06:00
edit.replace(TextRange::offset_len(offset, ((spaces + 1) as u32).into()), " ".to_string());
2019-01-10 08:50:49 -06:00
return;
}
// Special case that turns something like:
//
// ```
// my_function({<|>
// <some-expr>
// })
// ```
//
// into `my_function(<some-expr>)`
2019-03-30 05:25:53 -05:00
if join_single_expr_block(edit, token).is_some() {
2019-01-10 08:50:49 -06:00
return;
}
// ditto for
//
// ```
// use foo::{<|>
// bar
// };
// ```
2019-03-30 05:25:53 -05:00
if join_single_use_tree(edit, token).is_some() {
2019-01-10 08:50:49 -06:00
return;
}
// The node is between two other nodes
2019-03-30 05:25:53 -05:00
let prev = token.prev_sibling_or_token().unwrap();
let next = token.next_sibling_or_token().unwrap();
2019-01-10 08:50:49 -06:00
if is_trailing_comma(prev.kind(), next.kind()) {
// Removes: trailing comma, newline (incl. surrounding whitespace)
2019-03-30 05:25:53 -05:00
edit.delete(TextRange::from_to(prev.range().start(), token.range().end()));
2019-01-10 08:50:49 -06:00
} else if prev.kind() == COMMA && next.kind() == R_CURLY {
// Removes: comma, newline (incl. surrounding whitespace)
2019-03-30 05:25:53 -05:00
let space = if let Some(left) = prev.prev_sibling_or_token() {
compute_ws(left.kind(), next.kind())
} else {
" "
};
2019-01-10 08:50:49 -06:00
edit.replace(
2019-03-30 05:25:53 -05:00
TextRange::from_to(prev.range().start(), token.range().end()),
2019-01-10 08:50:49 -06:00
space.to_string(),
);
2019-03-30 05:25:53 -05:00
} else if let (Some(_), Some(next)) =
(prev.as_token().and_then(ast::Comment::cast), next.as_token().and_then(ast::Comment::cast))
{
2019-01-10 08:50:49 -06:00
// Removes: newline (incl. surrounding whitespace), start of the next comment
edit.delete(TextRange::from_to(
2019-03-30 05:25:53 -05:00
token.range().start(),
2019-01-10 08:50:49 -06:00
next.syntax().range().start() + TextUnit::of_str(next.prefix()),
));
} else {
// Remove newline but add a computed amount of whitespace characters
2019-03-30 05:25:53 -05:00
edit.replace(token.range(), compute_ws(prev.kind(), next.kind()).to_string());
2019-01-10 08:50:49 -06:00
}
}
fn has_comma_after(node: &SyntaxNode) -> bool {
2019-03-30 05:25:53 -05:00
match non_trivia_sibling(node.into(), Direction::Next) {
Some(n) => n.kind() == COMMA,
_ => false,
}
}
2019-03-30 05:25:53 -05:00
fn join_single_expr_block(edit: &mut TextEditBuilder, token: SyntaxToken) -> Option<()> {
let block = ast::Block::cast(token.parent())?;
2019-01-10 08:50:49 -06:00
let block_expr = ast::BlockExpr::cast(block.syntax().parent()?)?;
2019-01-10 09:32:02 -06:00
let expr = extract_trivial_expression(block)?;
let block_range = block_expr.syntax().range();
let mut buf = expr.syntax().text().to_string();
// Match block needs to have a comma after the block
if let Some(match_arm) = block_expr.syntax().parent().and_then(ast::MatchArm::cast) {
if !has_comma_after(match_arm.syntax()) {
buf.push(',');
}
}
edit.replace(block_range, buf);
2019-01-10 08:50:49 -06:00
Some(())
}
2019-03-30 05:25:53 -05:00
fn join_single_use_tree(edit: &mut TextEditBuilder, token: SyntaxToken) -> Option<()> {
let use_tree_list = ast::UseTreeList::cast(token.parent())?;
2019-01-10 08:50:49 -06:00
let (tree,) = use_tree_list.use_trees().collect_tuple()?;
2019-02-08 05:49:43 -06:00
edit.replace(use_tree_list.syntax().range(), tree.syntax().text().to_string());
2019-01-10 08:50:49 -06:00
Some(())
}
fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
match (left, right) {
(COMMA, R_PAREN) | (COMMA, R_BRACK) => true,
_ => false,
}
}
#[cfg(test)]
mod tests {
use crate::test_utils::{assert_eq_text, check_action, extract_range};
use super::*;
fn check_join_lines(before: &str, after: &str) {
check_action(before, after, |file, offset| {
let range = TextRange::offset_len(offset, 0.into());
let res = join_lines(file, range);
Some(res)
})
}
#[test]
fn test_join_lines_comma() {
check_join_lines(
r"
fn foo() {
<|>foo(1,
)
}
",
r"
fn foo() {
<|>foo(1)
}
",
);
}
#[test]
fn test_join_lines_lambda_block() {
check_join_lines(
r"
pub fn reparse(&self, edit: &AtomTextEdit) -> File {
<|>self.incremental_reparse(edit).unwrap_or_else(|| {
self.full_reparse(edit)
})
}
",
r"
pub fn reparse(&self, edit: &AtomTextEdit) -> File {
<|>self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
}
",
);
}
#[test]
fn test_join_lines_block() {
check_join_lines(
r"
fn foo() {
foo(<|>{
92
})
}",
r"
fn foo() {
foo(<|>92)
}",
);
}
2019-02-21 05:06:21 -06:00
#[test]
fn join_lines_adds_comma_for_block_in_match_arm() {
check_join_lines(
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>{
u.foo()
}
Err(v) => v,
}
}",
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>u.foo(),
Err(v) => v,
}
}",
);
}
#[test]
fn join_lines_keeps_comma_for_block_in_match_arm() {
// We already have a comma
check_join_lines(
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>{
u.foo()
},
Err(v) => v,
}
}",
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>u.foo(),
Err(v) => v,
}
}",
);
// comma with whitespace between brace and ,
check_join_lines(
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>{
u.foo()
} ,
Err(v) => v,
}
}",
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>u.foo() ,
Err(v) => v,
}
}",
);
// comma with newline between brace and ,
check_join_lines(
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>{
u.foo()
}
,
Err(v) => v,
}
}",
r"
fn foo(e: Result<U, V>) {
match e {
Ok(u) => <|>u.foo()
,
Err(v) => v,
}
}",
);
}
#[test]
fn join_lines_keeps_comma_with_single_arg_tuple() {
// A single arg tuple
check_join_lines(
r"
fn foo() {
let x = (<|>{
4
},);
}",
r"
fn foo() {
let x = (<|>4,);
}",
);
// single arg tuple with whitespace between brace and comma
check_join_lines(
r"
fn foo() {
let x = (<|>{
4
} ,);
}",
r"
fn foo() {
let x = (<|>4 ,);
}",
);
// single arg tuple with newline between brace and comma
check_join_lines(
r"
fn foo() {
let x = (<|>{
4
}
,);
}",
r"
fn foo() {
let x = (<|>4
,);
}",
);
}
2019-01-10 08:50:49 -06:00
#[test]
fn test_join_lines_use_items_left() {
// No space after the '{'
check_join_lines(
r"
<|>use ra_syntax::{
TextUnit, TextRange,
};",
r"
<|>use ra_syntax::{TextUnit, TextRange,
};",
);
}
#[test]
fn test_join_lines_use_items_right() {
// No space after the '}'
check_join_lines(
r"
use ra_syntax::{
<|> TextUnit, TextRange
};",
r"
use ra_syntax::{
<|> TextUnit, TextRange};",
);
}
#[test]
fn test_join_lines_use_items_right_comma() {
// No space after the '}'
check_join_lines(
r"
use ra_syntax::{
<|> TextUnit, TextRange,
};",
r"
use ra_syntax::{
<|> TextUnit, TextRange};",
);
}
#[test]
fn test_join_lines_use_tree() {
check_join_lines(
r"
use ra_syntax::{
algo::<|>{
2019-03-30 05:25:53 -05:00
find_token_at_offset,
2019-01-10 08:50:49 -06:00
},
ast,
};",
r"
use ra_syntax::{
2019-03-30 05:25:53 -05:00
algo::<|>find_token_at_offset,
2019-01-10 08:50:49 -06:00
ast,
};",
);
}
#[test]
fn test_join_lines_normal_comments() {
check_join_lines(
r"
fn foo() {
// Hello<|>
// world!
}
",
r"
fn foo() {
// Hello<|> world!
}
",
);
}
#[test]
fn test_join_lines_doc_comments() {
check_join_lines(
r"
fn foo() {
/// Hello<|>
/// world!
}
",
r"
fn foo() {
/// Hello<|> world!
}
",
);
}
#[test]
fn test_join_lines_mod_comments() {
check_join_lines(
r"
fn foo() {
//! Hello<|>
//! world!
}
",
r"
fn foo() {
//! Hello<|> world!
}
",
);
}
#[test]
fn test_join_lines_multiline_comments_1() {
check_join_lines(
r"
fn foo() {
// Hello<|>
/* world! */
}
",
r"
fn foo() {
// Hello<|> world! */
}
",
);
}
#[test]
fn test_join_lines_multiline_comments_2() {
check_join_lines(
r"
fn foo() {
// The<|>
/* quick
brown
fox! */
}
",
r"
fn foo() {
// The<|> quick
brown
fox! */
}
",
);
}
fn check_join_lines_sel(before: &str, after: &str) {
let (sel, before) = extract_range(before);
let file = SourceFile::parse(&before);
let result = join_lines(&file, sel);
2019-03-22 11:10:20 -05:00
let actual = result.apply(&before);
2019-01-10 08:50:49 -06:00
assert_eq_text!(after, &actual);
}
#[test]
fn test_join_lines_selection_fn_args() {
check_join_lines_sel(
r"
fn foo() {
<|>foo(1,
2,
3,
<|>)
}
",
r"
fn foo() {
foo(1, 2, 3)
}
",
);
}
#[test]
fn test_join_lines_selection_struct() {
check_join_lines_sel(
r"
struct Foo <|>{
f: u32,
}<|>
",
r"
struct Foo { f: u32 }
",
);
}
#[test]
fn test_join_lines_selection_dot_chain() {
check_join_lines_sel(
r"
fn foo() {
join(<|>type_params.type_params()
.filter_map(|it| it.name())
.map(|it| it.text())<|>)
}",
r"
fn foo() {
join(type_params.type_params().filter_map(|it| it.name()).map(|it| it.text()))
}",
);
}
#[test]
fn test_join_lines_selection_lambda_block_body() {
check_join_lines_sel(
r"
pub fn handle_find_matching_brace() {
params.offsets
.map(|offset| <|>{
world.analysis().matching_brace(&file, offset).unwrap_or(offset)
}<|>)
.collect();
}",
r"
pub fn handle_find_matching_brace() {
params.offsets
.map(|offset| world.analysis().matching_brace(&file, offset).unwrap_or(offset))
.collect();
}",
);
}
}