1088 lines
21 KiB
Rust
1088 lines
21 KiB
Rust
use ide_assists::utils::extract_trivial_expression;
|
|
use ide_db::syntax_helpers::node_ext::expr_as_name_ref;
|
|
use itertools::Itertools;
|
|
use syntax::{
|
|
ast::{self, AstNode, AstToken, IsString},
|
|
NodeOrToken, SourceFile, SyntaxElement,
|
|
SyntaxKind::{self, USE_TREE, WHITESPACE},
|
|
SyntaxToken, TextRange, TextSize, T,
|
|
};
|
|
|
|
use text_edit::{TextEdit, TextEditBuilder};
|
|
|
|
pub struct JoinLinesConfig {
|
|
pub join_else_if: bool,
|
|
pub remove_trailing_comma: bool,
|
|
pub unwrap_trivial_blocks: bool,
|
|
pub join_assignments: bool,
|
|
}
|
|
|
|
// Feature: Join Lines
|
|
//
|
|
// Join selected lines into one, smartly fixing up whitespace, trailing commas, and braces.
|
|
//
|
|
// See
|
|
// https://user-images.githubusercontent.com/1711539/124515923-4504e800-dde9-11eb-8d58-d97945a1a785.gif[this gif]
|
|
// for the cases handled specially by joined lines.
|
|
//
|
|
// |===
|
|
// | Editor | Action Name
|
|
//
|
|
// | VS Code | **rust-analyzer: Join lines**
|
|
// |===
|
|
//
|
|
// image::https://user-images.githubusercontent.com/48062697/113020661-b6922200-917a-11eb-87c4-b75acc028f11.gif[]
|
|
pub(crate) fn join_lines(
|
|
config: &JoinLinesConfig,
|
|
file: &SourceFile,
|
|
range: TextRange,
|
|
) -> TextEdit {
|
|
let range = if range.is_empty() {
|
|
let syntax = file.syntax();
|
|
let text = syntax.text().slice(range.start()..);
|
|
let pos = match text.find_char('\n') {
|
|
None => return TextEdit::builder().finish(),
|
|
Some(pos) => pos,
|
|
};
|
|
TextRange::at(range.start() + pos, TextSize::of('\n'))
|
|
} else {
|
|
range
|
|
};
|
|
|
|
let mut edit = TextEdit::builder();
|
|
match file.syntax().covering_element(range) {
|
|
NodeOrToken::Node(node) => {
|
|
for token in node.descendants_with_tokens().filter_map(|it| it.into_token()) {
|
|
remove_newlines(config, &mut edit, &token, range)
|
|
}
|
|
}
|
|
NodeOrToken::Token(token) => remove_newlines(config, &mut edit, &token, range),
|
|
};
|
|
edit.finish()
|
|
}
|
|
|
|
fn remove_newlines(
|
|
config: &JoinLinesConfig,
|
|
edit: &mut TextEditBuilder,
|
|
token: &SyntaxToken,
|
|
range: TextRange,
|
|
) {
|
|
let intersection = match range.intersect(token.text_range()) {
|
|
Some(range) => range,
|
|
None => return,
|
|
};
|
|
|
|
let range = intersection - token.text_range().start();
|
|
let text = token.text();
|
|
for (pos, _) in text[range].bytes().enumerate().filter(|&(_, b)| b == b'\n') {
|
|
let pos: TextSize = (pos as u32).into();
|
|
let offset = token.text_range().start() + range.start() + pos;
|
|
if !edit.invalidates_offset(offset) {
|
|
remove_newline(config, edit, token, offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn remove_newline(
|
|
config: &JoinLinesConfig,
|
|
edit: &mut TextEditBuilder,
|
|
token: &SyntaxToken,
|
|
offset: TextSize,
|
|
) {
|
|
if token.kind() != WHITESPACE || token.text().bytes().filter(|&b| b == b'\n').count() != 1 {
|
|
let n_spaces_after_line_break = {
|
|
let suff = &token.text()[TextRange::new(
|
|
offset - token.text_range().start() + TextSize::of('\n'),
|
|
TextSize::of(token.text()),
|
|
)];
|
|
suff.bytes().take_while(|&b| b == b' ').count()
|
|
};
|
|
|
|
let mut no_space = false;
|
|
if let Some(string) = ast::String::cast(token.clone()) {
|
|
if let Some(range) = string.open_quote_text_range() {
|
|
cov_mark::hit!(join_string_literal_open_quote);
|
|
no_space |= range.end() == offset;
|
|
}
|
|
if let Some(range) = string.close_quote_text_range() {
|
|
cov_mark::hit!(join_string_literal_close_quote);
|
|
no_space |= range.start()
|
|
== offset
|
|
+ TextSize::of('\n')
|
|
+ TextSize::try_from(n_spaces_after_line_break).unwrap();
|
|
}
|
|
}
|
|
|
|
let range = TextRange::at(offset, ((n_spaces_after_line_break + 1) as u32).into());
|
|
let replace_with = if no_space { "" } else { " " };
|
|
edit.replace(range, replace_with.to_string());
|
|
return;
|
|
}
|
|
|
|
// The node is between two other nodes
|
|
let (prev, next) = match (token.prev_sibling_or_token(), token.next_sibling_or_token()) {
|
|
(Some(prev), Some(next)) => (prev, next),
|
|
_ => return,
|
|
};
|
|
|
|
if config.remove_trailing_comma && prev.kind() == T![,] {
|
|
match next.kind() {
|
|
T![')'] | T![']'] => {
|
|
// Removes: trailing comma, newline (incl. surrounding whitespace)
|
|
edit.delete(TextRange::new(prev.text_range().start(), token.text_range().end()));
|
|
return;
|
|
}
|
|
T!['}'] => {
|
|
// Removes: comma, newline (incl. surrounding whitespace)
|
|
let space = match prev.prev_sibling_or_token() {
|
|
Some(left) => compute_ws(left.kind(), next.kind()),
|
|
None => " ",
|
|
};
|
|
edit.replace(
|
|
TextRange::new(prev.text_range().start(), token.text_range().end()),
|
|
space.to_string(),
|
|
);
|
|
return;
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
if config.join_else_if {
|
|
if let (Some(prev), Some(_next)) = (as_if_expr(&prev), as_if_expr(&next)) {
|
|
match prev.else_token() {
|
|
Some(_) => cov_mark::hit!(join_two_ifs_with_existing_else),
|
|
None => {
|
|
cov_mark::hit!(join_two_ifs);
|
|
edit.replace(token.text_range(), " else ".to_string());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if config.join_assignments {
|
|
if join_assignments(edit, &prev, &next).is_some() {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if config.unwrap_trivial_blocks {
|
|
// Special case that turns something like:
|
|
//
|
|
// ```
|
|
// my_function({$0
|
|
// <some-expr>
|
|
// })
|
|
// ```
|
|
//
|
|
// into `my_function(<some-expr>)`
|
|
if join_single_expr_block(edit, token).is_some() {
|
|
return;
|
|
}
|
|
// ditto for
|
|
//
|
|
// ```
|
|
// use foo::{$0
|
|
// bar
|
|
// };
|
|
// ```
|
|
if join_single_use_tree(edit, token).is_some() {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if let (Some(_), Some(next)) = (
|
|
prev.as_token().cloned().and_then(ast::Comment::cast),
|
|
next.as_token().cloned().and_then(ast::Comment::cast),
|
|
) {
|
|
// Removes: newline (incl. surrounding whitespace), start of the next comment
|
|
edit.delete(TextRange::new(
|
|
token.text_range().start(),
|
|
next.syntax().text_range().start() + TextSize::of(next.prefix()),
|
|
));
|
|
return;
|
|
}
|
|
|
|
// Remove newline but add a computed amount of whitespace characters
|
|
edit.replace(token.text_range(), compute_ws(prev.kind(), next.kind()).to_string());
|
|
}
|
|
|
|
fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
|
|
let block_expr = ast::BlockExpr::cast(token.parent_ancestors().nth(1)?)?;
|
|
if !block_expr.is_standalone() {
|
|
return None;
|
|
}
|
|
let expr = extract_trivial_expression(&block_expr)?;
|
|
|
|
let block_range = block_expr.syntax().text_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 match_arm.comma_token().is_none() {
|
|
buf.push(',');
|
|
}
|
|
}
|
|
|
|
edit.replace(block_range, buf);
|
|
|
|
Some(())
|
|
}
|
|
|
|
fn join_single_use_tree(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
|
|
let use_tree_list = ast::UseTreeList::cast(token.parent()?)?;
|
|
let (tree,) = use_tree_list.use_trees().collect_tuple()?;
|
|
edit.replace(use_tree_list.syntax().text_range(), tree.syntax().text().to_string());
|
|
Some(())
|
|
}
|
|
|
|
fn join_assignments(
|
|
edit: &mut TextEditBuilder,
|
|
prev: &SyntaxElement,
|
|
next: &SyntaxElement,
|
|
) -> Option<()> {
|
|
let let_stmt = ast::LetStmt::cast(prev.as_node()?.clone())?;
|
|
if let_stmt.eq_token().is_some() {
|
|
cov_mark::hit!(join_assignments_already_initialized);
|
|
return None;
|
|
}
|
|
let let_ident_pat = match let_stmt.pat()? {
|
|
ast::Pat::IdentPat(it) => it,
|
|
_ => return None,
|
|
};
|
|
|
|
let expr_stmt = ast::ExprStmt::cast(next.as_node()?.clone())?;
|
|
let bin_expr = match expr_stmt.expr()? {
|
|
ast::Expr::BinExpr(it) => it,
|
|
_ => return None,
|
|
};
|
|
if !matches!(bin_expr.op_kind()?, ast::BinaryOp::Assignment { op: None }) {
|
|
return None;
|
|
}
|
|
let lhs = bin_expr.lhs()?;
|
|
let name_ref = expr_as_name_ref(&lhs)?;
|
|
|
|
if name_ref.to_string() != let_ident_pat.syntax().to_string() {
|
|
cov_mark::hit!(join_assignments_mismatch);
|
|
return None;
|
|
}
|
|
|
|
edit.delete(let_stmt.semicolon_token()?.text_range().cover(lhs.syntax().text_range()));
|
|
Some(())
|
|
}
|
|
|
|
fn as_if_expr(element: &SyntaxElement) -> Option<ast::IfExpr> {
|
|
let mut node = element.as_node()?.clone();
|
|
if let Some(stmt) = ast::ExprStmt::cast(node.clone()) {
|
|
node = stmt.expr()?.syntax().clone();
|
|
}
|
|
ast::IfExpr::cast(node)
|
|
}
|
|
|
|
fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
|
|
match left {
|
|
T!['('] | T!['['] => return "",
|
|
T!['{'] => {
|
|
if let USE_TREE = right {
|
|
return "";
|
|
}
|
|
}
|
|
_ => (),
|
|
}
|
|
match right {
|
|
T![')'] | T![']'] => return "",
|
|
T!['}'] => {
|
|
if let USE_TREE = left {
|
|
return "";
|
|
}
|
|
}
|
|
T![.] => return "",
|
|
_ => (),
|
|
}
|
|
" "
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use syntax::SourceFile;
|
|
use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
|
|
|
|
use super::*;
|
|
|
|
fn check_join_lines(ra_fixture_before: &str, ra_fixture_after: &str) {
|
|
let config = JoinLinesConfig {
|
|
join_else_if: true,
|
|
remove_trailing_comma: true,
|
|
unwrap_trivial_blocks: true,
|
|
join_assignments: true,
|
|
};
|
|
|
|
let (before_cursor_pos, before) = extract_offset(ra_fixture_before);
|
|
let file = SourceFile::parse(&before).ok().unwrap();
|
|
|
|
let range = TextRange::empty(before_cursor_pos);
|
|
let result = join_lines(&config, &file, range);
|
|
|
|
let actual = {
|
|
let mut actual = before;
|
|
result.apply(&mut actual);
|
|
actual
|
|
};
|
|
let actual_cursor_pos = result
|
|
.apply_to_offset(before_cursor_pos)
|
|
.expect("cursor position is affected by the edit");
|
|
let actual = add_cursor(&actual, actual_cursor_pos);
|
|
assert_eq_text!(ra_fixture_after, &actual);
|
|
}
|
|
|
|
fn check_join_lines_sel(ra_fixture_before: &str, ra_fixture_after: &str) {
|
|
let config = JoinLinesConfig {
|
|
join_else_if: true,
|
|
remove_trailing_comma: true,
|
|
unwrap_trivial_blocks: true,
|
|
join_assignments: true,
|
|
};
|
|
|
|
let (sel, before) = extract_range(ra_fixture_before);
|
|
let parse = SourceFile::parse(&before);
|
|
let result = join_lines(&config, &parse.tree(), sel);
|
|
let actual = {
|
|
let mut actual = before;
|
|
result.apply(&mut actual);
|
|
actual
|
|
};
|
|
assert_eq_text!(ra_fixture_after, &actual);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_comma() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
$0foo(1,
|
|
)
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
$0foo(1)
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_lambda_block() {
|
|
check_join_lines(
|
|
r"
|
|
pub fn reparse(&self, edit: &AtomTextEdit) -> File {
|
|
$0self.incremental_reparse(edit).unwrap_or_else(|| {
|
|
self.full_reparse(edit)
|
|
})
|
|
}
|
|
",
|
|
r"
|
|
pub fn reparse(&self, edit: &AtomTextEdit) -> File {
|
|
$0self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_block() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
foo($0{
|
|
92
|
|
})
|
|
}",
|
|
r"
|
|
fn foo() {
|
|
foo($092)
|
|
}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_diverging_block() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
loop {
|
|
match x {
|
|
92 => $0{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
loop {
|
|
match x {
|
|
92 => $0continue,
|
|
}
|
|
}
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[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) => $0{
|
|
u.foo()
|
|
}
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0u.foo(),
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_lines_multiline_in_block() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
match ty {
|
|
$0 Some(ty) => {
|
|
match ty {
|
|
_ => false,
|
|
}
|
|
}
|
|
_ => true,
|
|
}
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
match ty {
|
|
$0 Some(ty) => match ty {
|
|
_ => false,
|
|
},
|
|
_ => true,
|
|
}
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[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) => $0{
|
|
u.foo()
|
|
},
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0u.foo(),
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
);
|
|
|
|
// comma with whitespace between brace and ,
|
|
check_join_lines(
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0{
|
|
u.foo()
|
|
} ,
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0u.foo() ,
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
);
|
|
|
|
// comma with newline between brace and ,
|
|
check_join_lines(
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0{
|
|
u.foo()
|
|
}
|
|
,
|
|
Err(v) => v,
|
|
}
|
|
}",
|
|
r"
|
|
fn foo(e: Result<U, V>) {
|
|
match e {
|
|
Ok(u) => $0u.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 = ($0{
|
|
4
|
|
},);
|
|
}",
|
|
r"
|
|
fn foo() {
|
|
let x = ($04,);
|
|
}",
|
|
);
|
|
|
|
// single arg tuple with whitespace between brace and comma
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
let x = ($0{
|
|
4
|
|
} ,);
|
|
}",
|
|
r"
|
|
fn foo() {
|
|
let x = ($04 ,);
|
|
}",
|
|
);
|
|
|
|
// single arg tuple with newline between brace and comma
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
let x = ($0{
|
|
4
|
|
}
|
|
,);
|
|
}",
|
|
r"
|
|
fn foo() {
|
|
let x = ($04
|
|
,);
|
|
}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_use_items_left() {
|
|
// No space after the '{'
|
|
check_join_lines(
|
|
r"
|
|
$0use syntax::{
|
|
TextSize, TextRange,
|
|
};",
|
|
r"
|
|
$0use syntax::{TextSize, TextRange,
|
|
};",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_use_items_right() {
|
|
// No space after the '}'
|
|
check_join_lines(
|
|
r"
|
|
use syntax::{
|
|
$0 TextSize, TextRange
|
|
};",
|
|
r"
|
|
use syntax::{
|
|
$0 TextSize, TextRange};",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_use_items_right_comma() {
|
|
// No space after the '}'
|
|
check_join_lines(
|
|
r"
|
|
use syntax::{
|
|
$0 TextSize, TextRange,
|
|
};",
|
|
r"
|
|
use syntax::{
|
|
$0 TextSize, TextRange};",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_use_tree() {
|
|
check_join_lines(
|
|
r"
|
|
use syntax::{
|
|
algo::$0{
|
|
find_token_at_offset,
|
|
},
|
|
ast,
|
|
};",
|
|
r"
|
|
use syntax::{
|
|
algo::$0find_token_at_offset,
|
|
ast,
|
|
};",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_normal_comments() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
// Hello$0
|
|
// world!
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
// Hello$0 world!
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_doc_comments() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
/// Hello$0
|
|
/// world!
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
/// Hello$0 world!
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_mod_comments() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
//! Hello$0
|
|
//! world!
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
//! Hello$0 world!
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_multiline_comments_1() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
// Hello$0
|
|
/* world! */
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
// Hello$0 world! */
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_multiline_comments_2() {
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
// The$0
|
|
/* quick
|
|
brown
|
|
fox! */
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
// The$0 quick
|
|
brown
|
|
fox! */
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_selection_fn_args() {
|
|
check_join_lines_sel(
|
|
r"
|
|
fn foo() {
|
|
$0foo(1,
|
|
2,
|
|
3,
|
|
$0)
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
foo(1, 2, 3)
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_selection_struct() {
|
|
check_join_lines_sel(
|
|
r"
|
|
struct Foo $0{
|
|
f: u32,
|
|
}$0
|
|
",
|
|
r"
|
|
struct Foo { f: u32 }
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_selection_dot_chain() {
|
|
check_join_lines_sel(
|
|
r"
|
|
fn foo() {
|
|
join($0type_params.type_params()
|
|
.filter_map(|it| it.name())
|
|
.map(|it| it.text())$0)
|
|
}",
|
|
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| $0{
|
|
world.analysis().matching_brace(&file, offset).unwrap_or(offset)
|
|
}$0)
|
|
.collect();
|
|
}",
|
|
r"
|
|
pub fn handle_find_matching_brace() {
|
|
params.offsets
|
|
.map(|offset| world.analysis().matching_brace(&file, offset).unwrap_or(offset))
|
|
.collect();
|
|
}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_lines_commented_block() {
|
|
check_join_lines(
|
|
r"
|
|
fn main() {
|
|
let _ = {
|
|
// $0foo
|
|
// bar
|
|
92
|
|
};
|
|
}
|
|
",
|
|
r"
|
|
fn main() {
|
|
let _ = {
|
|
// $0foo bar
|
|
92
|
|
};
|
|
}
|
|
",
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn join_lines_mandatory_blocks_block() {
|
|
check_join_lines(
|
|
r"
|
|
$0fn foo() {
|
|
92
|
|
}
|
|
",
|
|
r"
|
|
$0fn foo() { 92
|
|
}
|
|
",
|
|
);
|
|
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
$0if true {
|
|
92
|
|
}
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
$0if true { 92
|
|
}
|
|
}
|
|
",
|
|
);
|
|
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
$0loop {
|
|
92
|
|
}
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
$0loop { 92
|
|
}
|
|
}
|
|
",
|
|
);
|
|
|
|
check_join_lines(
|
|
r"
|
|
fn foo() {
|
|
$0unsafe {
|
|
92
|
|
}
|
|
}
|
|
",
|
|
r"
|
|
fn foo() {
|
|
$0unsafe { 92
|
|
}
|
|
}
|
|
",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_string_literal() {
|
|
{
|
|
cov_mark::check!(join_string_literal_open_quote);
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
$0"
|
|
hello
|
|
";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
$0"hello
|
|
";
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
{
|
|
cov_mark::check!(join_string_literal_close_quote);
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
$0"hello
|
|
";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
$0"hello";
|
|
}
|
|
"#,
|
|
);
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
$0r"hello
|
|
";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
$0r"hello";
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
"
|
|
$0hello
|
|
world
|
|
";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
"
|
|
$0hello world
|
|
";
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_last_line_empty() {
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {$0}
|
|
"#,
|
|
r#"
|
|
fn main() {$0}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_two_ifs() {
|
|
cov_mark::check!(join_two_ifs);
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
if foo {
|
|
|
|
}$0
|
|
if bar {
|
|
|
|
}
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
if foo {
|
|
|
|
}$0 else if bar {
|
|
|
|
}
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_two_ifs_with_existing_else() {
|
|
cov_mark::check!(join_two_ifs_with_existing_else);
|
|
check_join_lines(
|
|
r#"
|
|
fn main() {
|
|
if foo {
|
|
|
|
} else {
|
|
|
|
}$0
|
|
if bar {
|
|
|
|
}
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
if foo {
|
|
|
|
} else {
|
|
|
|
}$0 if bar {
|
|
|
|
}
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_assignments() {
|
|
check_join_lines(
|
|
r#"
|
|
fn foo() {
|
|
$0let foo;
|
|
foo = "bar";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn foo() {
|
|
$0let foo = "bar";
|
|
}
|
|
"#,
|
|
);
|
|
|
|
cov_mark::check!(join_assignments_mismatch);
|
|
check_join_lines(
|
|
r#"
|
|
fn foo() {
|
|
let foo;
|
|
let qux;$0
|
|
foo = "bar";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn foo() {
|
|
let foo;
|
|
let qux;$0 foo = "bar";
|
|
}
|
|
"#,
|
|
);
|
|
|
|
cov_mark::check!(join_assignments_already_initialized);
|
|
check_join_lines(
|
|
r#"
|
|
fn foo() {
|
|
let foo = "bar";$0
|
|
foo = "bar";
|
|
}
|
|
"#,
|
|
r#"
|
|
fn foo() {
|
|
let foo = "bar";$0 foo = "bar";
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
}
|