use syntax::{
algo::find_node_at_offset,
ast::{self, edit::IndentLevel, AstToken},
- AstNode, SourceFile,
- SyntaxKind::{FIELD_EXPR, METHOD_CALL_EXPR},
+ AstNode, Parse, SourceFile,
+ SyntaxKind::{self, FIELD_EXPR, METHOD_CALL_EXPR},
TextRange, TextSize,
};
-use text_edit::TextEdit;
+use text_edit::{Indel, TextEdit};
use crate::SourceChange;
//
// - typing `let =` tries to smartly add `;` if `=` is followed by an existing expression
// - typing `.` in a chain method call auto-indents
+// - typing `{` in front of an expression inserts a closing `}` after the expression
//
// VS Code::
//
position: FilePosition,
char_typed: char,
) -> Option<SourceChange> {
- assert!(TRIGGER_CHARS.contains(char_typed));
- let file = &db.parse(position.file_id).tree();
- assert_eq!(file.syntax().text().char_at(position.offset), Some(char_typed));
+ if !stdx::always!(TRIGGER_CHARS.contains(char_typed)) {
+ return None;
+ }
+ let file = &db.parse(position.file_id);
+ if !stdx::always!(file.tree().syntax().text().char_at(position.offset) == Some(char_typed)) {
+ return None;
+ }
let edit = on_char_typed_inner(file, position.offset, char_typed)?;
Some(SourceChange::from_text_edit(position.file_id, edit))
}
-fn on_char_typed_inner(file: &SourceFile, offset: TextSize, char_typed: char) -> Option<TextEdit> {
- assert!(TRIGGER_CHARS.contains(char_typed));
+fn on_char_typed_inner(
+ file: &Parse<SourceFile>,
+ offset: TextSize,
+ char_typed: char,
+) -> Option<TextEdit> {
+ if !stdx::always!(TRIGGER_CHARS.contains(char_typed)) {
+ return None;
+ }
match char_typed {
- '.' => on_dot_typed(file, offset),
- '=' => on_eq_typed(file, offset),
- '>' => on_arrow_typed(file, offset),
+ '.' => on_dot_typed(&file.tree(), offset),
+ '=' => on_eq_typed(&file.tree(), offset),
+ '>' => on_arrow_typed(&file.tree(), offset),
'{' => on_opening_brace_typed(file, offset),
_ => unreachable!(),
}
}
/// Inserts a closing `}` when the user types an opening `{`, wrapping an existing expression in a
-/// block.
-fn on_opening_brace_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
- stdx::always!(file.syntax().text().char_at(offset) == Some('{'));
- let brace_token = file.syntax().token_at_offset(offset).right_biased()?;
- let block = ast::BlockExpr::cast(brace_token.parent()?)?;
-
- // We expect a block expression enclosing exactly 1 preexisting expression. It can be parsed as
- // either the trailing expr or an ExprStmt.
- let offset = {
- match block.statements().next() {
- Some(ast::Stmt::ExprStmt(it)) => {
- // Use the expression span to place `}` before the `;`
- it.expr()?.syntax().text_range().end()
+/// block, or a part of a `use` item.
+fn on_opening_brace_typed(file: &Parse<SourceFile>, offset: TextSize) -> Option<TextEdit> {
+ if !stdx::always!(file.tree().syntax().text().char_at(offset) == Some('{')) {
+ return None;
+ }
+
+ let brace_token = file.tree().syntax().token_at_offset(offset).right_biased()?;
+ if brace_token.kind() != SyntaxKind::L_CURLY {
+ return None;
+ }
+
+ // Remove the `{` to get a better parse tree, and reparse.
+ let range = brace_token.text_range();
+ if !stdx::always!(range.len() == TextSize::of('{')) {
+ return None;
+ }
+ let file = file.reparse(&Indel::delete(range));
+
+ if let Some(edit) = brace_expr(&file.tree(), offset) {
+ return Some(edit);
+ }
+
+ if let Some(edit) = brace_use_path(&file.tree(), offset) {
+ return Some(edit);
+ }
+
+ return None;
+
+ fn brace_use_path(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
+ let segment: ast::PathSegment = find_node_at_offset(file.syntax(), offset)?;
+ if segment.syntax().text_range().start() != offset {
+ return None;
+ }
+
+ let tree: ast::UseTree = find_node_at_offset(file.syntax(), offset)?;
+
+ Some(TextEdit::insert(
+ tree.syntax().text_range().end() + TextSize::of("{"),
+ "}".to_string(),
+ ))
+ }
+
+ fn brace_expr(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
+ let mut expr: ast::Expr = find_node_at_offset(file.syntax(), offset)?;
+ if expr.syntax().text_range().start() != offset {
+ return None;
+ }
+
+ // Enclose the outermost expression starting at `offset`
+ while let Some(parent) = expr.syntax().parent() {
+ if parent.text_range().start() != expr.syntax().text_range().start() {
+ break;
+ }
+
+ match ast::Expr::cast(parent) {
+ Some(parent) => expr = parent,
+ None => break,
}
- None => block.tail_expr()?.syntax().text_range().end(),
- _ => return None,
}
- };
- Some(TextEdit::insert(offset, "}".to_string()))
+ // If it's a statement in a block, we don't know how many statements should be included
+ if ast::ExprStmt::can_cast(expr.syntax().parent()?.kind()) {
+ return None;
+ }
+
+ // Insert `}` right after the expression.
+ Some(TextEdit::insert(
+ expr.syntax().text_range().end() + TextSize::of("{"),
+ "}".to_string(),
+ ))
+ }
}
/// Returns an edit which should be applied after `=` was typed. Primarily,
/// this works when adding `let =`.
// FIXME: use a snippet completion instead of this hack here.
fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
- stdx::always!(file.syntax().text().char_at(offset) == Some('='));
+ if !stdx::always!(file.syntax().text().char_at(offset) == Some('=')) {
+ return None;
+ }
let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
if let_stmt.semicolon_token().is_some() {
return None;
/// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately.
fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
- stdx::always!(file.syntax().text().char_at(offset) == Some('.'));
+ if !stdx::always!(file.syntax().text().char_at(offset) == Some('.')) {
+ return None;
+ }
let whitespace =
file.syntax().token_at_offset(offset).left_biased().and_then(ast::Whitespace::cast)?;
/// Adds a space after an arrow when `fn foo() { ... }` is turned into `fn foo() -> { ... }`
fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
let file_text = file.syntax().text();
- stdx::always!(file_text.char_at(offset) == Some('>'));
+ if !stdx::always!(file_text.char_at(offset) == Some('>')) {
+ return None;
+ }
let after_arrow = offset + TextSize::of('>');
if file_text.char_at(after_arrow) != Some('{') {
return None;
let edit = TextEdit::insert(offset, char_typed.to_string());
edit.apply(&mut before);
let parse = SourceFile::parse(&before);
- on_char_typed_inner(&parse.tree(), offset, char_typed).map(|it| {
+ on_char_typed_inner(&parse, offset, char_typed).map(|it| {
it.apply(&mut before);
before.to_string()
})
assert_eq_text!(ra_fixture_after, &actual);
}
- fn type_char_noop(char_typed: char, before: &str) {
- let file_change = do_type_char(char_typed, before);
+ fn type_char_noop(char_typed: char, ra_fixture_before: &str) {
+ let file_change = do_type_char(char_typed, ra_fixture_before);
assert!(file_change.is_none())
}
// ");
type_char(
'=',
- r"
+ r#"
fn foo() {
let foo $0 1 + 1
}
-",
- r"
+"#,
+ r#"
fn foo() {
let foo = 1 + 1;
}
-",
+"#,
);
// do_check(r"
// fn foo() {
fn indents_new_chain_call() {
type_char(
'.',
- r"
- fn main() {
- xs.foo()
- $0
- }
- ",
- r"
- fn main() {
- xs.foo()
- .
- }
- ",
+ r#"
+fn main() {
+ xs.foo()
+ $0
+}
+ "#,
+ r#"
+fn main() {
+ xs.foo()
+ .
+}
+ "#,
);
type_char_noop(
'.',
- r"
- fn main() {
- xs.foo()
- $0
- }
- ",
+ r#"
+fn main() {
+ xs.foo()
+ $0
+}
+ "#,
)
}
type_char(
'.',
r"
- fn main() {
- xs.foo()
- $0;
- }
- ",
- r"
- fn main() {
- xs.foo()
- .;
- }
+fn main() {
+ xs.foo()
+ $0;
+}
",
+ r#"
+fn main() {
+ xs.foo()
+ .;
+}
+ "#,
);
type_char_noop(
'.',
- r"
- fn main() {
- xs.foo()
- $0;
- }
- ",
+ r#"
+fn main() {
+ xs.foo()
+ $0;
+}
+ "#,
)
}
fn indents_continued_chain_call() {
type_char(
'.',
- r"
- fn main() {
- xs.foo()
- .first()
- $0
- }
- ",
- r"
- fn main() {
- xs.foo()
- .first()
- .
- }
- ",
+ r#"
+fn main() {
+ xs.foo()
+ .first()
+ $0
+}
+ "#,
+ r#"
+fn main() {
+ xs.foo()
+ .first()
+ .
+}
+ "#,
);
type_char_noop(
'.',
- r"
- fn main() {
- xs.foo()
- .first()
- $0
- }
- ",
+ r#"
+fn main() {
+ xs.foo()
+ .first()
+ $0
+}
+ "#,
);
}
fn indents_middle_of_chain_call() {
type_char(
'.',
- r"
- fn source_impl() {
- let var = enum_defvariant_list().unwrap()
- $0
- .nth(92)
- .unwrap();
- }
- ",
- r"
- fn source_impl() {
- let var = enum_defvariant_list().unwrap()
- .
- .nth(92)
- .unwrap();
- }
- ",
+ r#"
+fn source_impl() {
+ let var = enum_defvariant_list().unwrap()
+ $0
+ .nth(92)
+ .unwrap();
+}
+ "#,
+ r#"
+fn source_impl() {
+ let var = enum_defvariant_list().unwrap()
+ .
+ .nth(92)
+ .unwrap();
+}
+ "#,
);
type_char_noop(
'.',
- r"
- fn source_impl() {
- let var = enum_defvariant_list().unwrap()
- $0
- .nth(92)
- .unwrap();
- }
- ",
+ r#"
+fn source_impl() {
+ let var = enum_defvariant_list().unwrap()
+ $0
+ .nth(92)
+ .unwrap();
+}
+ "#,
);
}
fn dont_indent_freestanding_dot() {
type_char_noop(
'.',
- r"
- fn main() {
- $0
- }
- ",
+ r#"
+fn main() {
+ $0
+}
+ "#,
);
type_char_noop(
'.',
- r"
- fn main() {
- $0
- }
- ",
+ r#"
+fn main() {
+$0
+}
+ "#,
);
}
#[test]
fn adds_space_after_return_type() {
- type_char('>', "fn foo() -$0{ 92 }", "fn foo() -> { 92 }")
+ type_char(
+ '>',
+ r#"
+fn foo() -$0{ 92 }
+"#,
+ r#"
+fn foo() -> { 92 }
+"#,
+ );
}
#[test]
- fn adds_closing_brace() {
- type_char('{', r"fn f() { match () { _ => $0() } }", r"fn f() { match () { _ => {()} } }");
- type_char('{', r"fn f() { $0(); }", r"fn f() { {()}; }");
- type_char('{', r"fn f() { let x = $0(); }", r"fn f() { let x = {()}; }");
+ fn adds_closing_brace_for_expr() {
type_char(
'{',
- r"
- const S: () = $0();
- fn f() {}
- ",
- r"
- const S: () = {()};
- fn f() {}
- ",
+ r#"
+fn f() { match () { _ => $0() } }
+ "#,
+ r#"
+fn f() { match () { _ => {()} } }
+ "#,
);
type_char(
'{',
- r"
- fn f() {
- match x {
- 0 => $0(),
- 1 => (),
- }
- }",
- r"
- fn f() {
- match x {
- 0 => {()},
- 1 => (),
- }
- }",
+ r#"
+fn f() { $0() }
+ "#,
+ r#"
+fn f() { {()} }
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+fn f() { let x = $0(); }
+ "#,
+ r#"
+fn f() { let x = {()}; }
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+fn f() { let x = $0a.b(); }
+ "#,
+ r#"
+fn f() { let x = {a.b()}; }
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+const S: () = $0();
+fn f() {}
+ "#,
+ r#"
+const S: () = {()};
+fn f() {}
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+const S: () = $0a.b();
+fn f() {}
+ "#,
+ r#"
+const S: () = {a.b()};
+fn f() {}
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+fn f() {
+ match x {
+ 0 => $0(),
+ 1 => (),
+ }
+}
+ "#,
+ r#"
+fn f() {
+ match x {
+ 0 => {()},
+ 1 => (),
+ }
+}
+ "#,
+ );
+ }
+
+ #[test]
+ fn noop_in_string_literal() {
+ // Regression test for #9351
+ type_char_noop(
+ '{',
+ r##"
+fn check_with(ra_fixture: &str, expect: Expect) {
+ let base = r#"
+enum E { T(), R$0, C }
+use self::E::X;
+const Z: E = E::C;
+mod m {}
+asdasdasdasdasdasda
+sdasdasdasdasdasda
+sdasdasdasdasd
+"#;
+ let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+ expect.assert_eq(&actual)
+}
+ "##,
+ );
+ }
+
+ #[test]
+ fn adds_closing_brace_for_use_tree() {
+ type_char(
+ '{',
+ r#"
+use some::$0Path;
+ "#,
+ r#"
+use some::{Path};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use some::{Path, $0Other};
+ "#,
+ r#"
+use some::{Path, {Other}};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use some::{$0Path, Other};
+ "#,
+ r#"
+use some::{{Path}, Other};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use some::path::$0to::Item;
+ "#,
+ r#"
+use some::path::{to::Item};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use some::$0path::to::Item;
+ "#,
+ r#"
+use some::{path::to::Item};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use $0some::path::to::Item;
+ "#,
+ r#"
+use {some::path::to::Item};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use some::path::$0to::{Item};
+ "#,
+ r#"
+use some::path::{to::{Item}};
+ "#,
+ );
+ type_char(
+ '{',
+ r#"
+use $0Thing as _;
+ "#,
+ r#"
+use {Thing as _};
+ "#,
+ );
+
+ type_char_noop(
+ '{',
+ r#"
+use some::pa$0th::to::Item;
+ "#,
);
}
}
projects / rust.git / blobdiff