From 0c15deac760a654f03de3ae433e5260b5bdfb8c2 Mon Sep 17 00:00:00 2001 From: Wilco Kusee Date: Sat, 23 Mar 2019 12:07:21 +0100 Subject: Move typing to ra_ide_api --- crates/ra_ide_api/src/lib.rs | 7 +- crates/ra_ide_api/src/typing.rs | 408 ++++++++++++++++++++++++++++++++++ crates/ra_ide_api_light/src/lib.rs | 3 - crates/ra_ide_api_light/src/typing.rs | 407 --------------------------------- 4 files changed, 412 insertions(+), 413 deletions(-) create mode 100644 crates/ra_ide_api/src/typing.rs delete mode 100644 crates/ra_ide_api_light/src/typing.rs diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs index a838c30da..c2ef61ae2 100644 --- a/crates/ra_ide_api/src/lib.rs +++ b/crates/ra_ide_api/src/lib.rs @@ -37,6 +37,7 @@ mod line_index; mod folding_ranges; mod line_index_utils; mod join_lines; +mod typing; #[cfg(test)] mod marks; @@ -295,7 +296,7 @@ impl Analysis { /// up minor stuff like continuing the comment. pub fn on_enter(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_enter(&file, position.offset)?; + let edit = typing::on_enter(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } @@ -304,14 +305,14 @@ impl Analysis { // FIXME: use a snippet completion instead of this hack here. pub fn on_eq_typed(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_eq_typed(&file, position.offset)?; + let edit = typing::on_eq_typed(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately. pub fn on_dot_typed(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_dot_typed(&file, position.offset)?; + let edit = typing::on_dot_typed(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs new file mode 100644 index 000000000..b7e023d60 --- /dev/null +++ b/crates/ra_ide_api/src/typing.rs @@ -0,0 +1,408 @@ +use ra_syntax::{ + AstNode, SourceFile, SyntaxKind::*, + SyntaxNode, TextUnit, TextRange, + algo::{find_node_at_offset, find_leaf_at_offset, LeafAtOffset}, + ast::{self, AstToken}, +}; +use ra_fmt::leading_indent; +use crate::LocalEdit; +use ra_text_edit::TextEditBuilder; + +pub fn on_enter(file: &SourceFile, offset: TextUnit) -> Option { + let comment = + find_leaf_at_offset(file.syntax(), offset).left_biased().and_then(ast::Comment::cast)?; + + if let ast::CommentFlavor::Multiline = comment.flavor() { + return None; + } + + let prefix = comment.prefix(); + if offset < comment.syntax().range().start() + TextUnit::of_str(prefix) + TextUnit::from(1) { + return None; + } + + let indent = node_indent(file, comment.syntax())?; + let inserted = format!("\n{}{} ", indent, prefix); + let cursor_position = offset + TextUnit::of_str(&inserted); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, inserted); + Some(LocalEdit { + label: "on enter".to_string(), + edit: edit.finish(), + cursor_position: Some(cursor_position), + }) +} + +fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> { + let ws = match find_leaf_at_offset(file.syntax(), node.range().start()) { + LeafAtOffset::Between(l, r) => { + assert!(r == node); + l + } + LeafAtOffset::Single(n) => { + assert!(n == node); + return Some(""); + } + LeafAtOffset::None => unreachable!(), + }; + if ws.kind() != WHITESPACE { + return None; + } + let text = ws.leaf_text().unwrap(); + let pos = text.as_str().rfind('\n').map(|it| it + 1).unwrap_or(0); + Some(&text[pos..]) +} + +pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option { + assert_eq!(file.syntax().text().char_at(eq_offset), Some('=')); + let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?; + if let_stmt.has_semi() { + return None; + } + if let Some(expr) = let_stmt.initializer() { + let expr_range = expr.syntax().range(); + if expr_range.contains(eq_offset) && eq_offset != expr_range.start() { + return None; + } + if file.syntax().text().slice(eq_offset..expr_range.start()).contains('\n') { + return None; + } + } else { + return None; + } + let offset = let_stmt.syntax().range().end(); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, ";".to_string()); + Some(LocalEdit { + label: "add semicolon".to_string(), + edit: edit.finish(), + cursor_position: None, + }) +} + +pub fn on_dot_typed(file: &SourceFile, dot_offset: TextUnit) -> Option { + assert_eq!(file.syntax().text().char_at(dot_offset), Some('.')); + + let whitespace = find_leaf_at_offset(file.syntax(), dot_offset) + .left_biased() + .and_then(ast::Whitespace::cast)?; + + let current_indent = { + let text = whitespace.text(); + let newline = text.rfind('\n')?; + &text[newline + 1..] + }; + let current_indent_len = TextUnit::of_str(current_indent); + + // Make sure dot is a part of call chain + let field_expr = whitespace.syntax().parent().and_then(ast::FieldExpr::cast)?; + let prev_indent = leading_indent(field_expr.syntax())?; + let target_indent = format!(" {}", prev_indent); + let target_indent_len = TextUnit::of_str(&target_indent); + if current_indent_len == target_indent_len { + return None; + } + let mut edit = TextEditBuilder::default(); + edit.replace( + TextRange::from_to(dot_offset - current_indent_len, dot_offset), + target_indent.into(), + ); + let res = LocalEdit { + label: "reindent dot".to_string(), + edit: edit.finish(), + cursor_position: Some( + dot_offset + target_indent_len - current_indent_len + TextUnit::of_char('.'), + ), + }; + Some(res) +} + +#[cfg(test)] +mod tests { + use test_utils::{add_cursor, assert_eq_text, extract_offset}; + + use super::*; + + #[test] + fn test_on_eq_typed() { + fn type_eq(before: &str, after: &str) { + let (offset, before) = extract_offset(before); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, "=".to_string()); + let before = edit.finish().apply(&before); + let file = SourceFile::parse(&before); + if let Some(result) = on_eq_typed(&file, offset) { + let actual = result.edit.apply(&before); + assert_eq_text!(after, &actual); + } else { + assert_eq_text!(&before, after) + }; + } + + // do_check(r" + // fn foo() { + // let foo =<|> + // } + // ", r" + // fn foo() { + // let foo =; + // } + // "); + type_eq( + r" +fn foo() { + let foo <|> 1 + 1 +} +", + r" +fn foo() { + let foo = 1 + 1; +} +", + ); + // do_check(r" + // fn foo() { + // let foo =<|> + // let bar = 1; + // } + // ", r" + // fn foo() { + // let foo =; + // let bar = 1; + // } + // "); + } + + fn type_dot(before: &str, after: &str) { + let (offset, before) = extract_offset(before); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, ".".to_string()); + let before = edit.finish().apply(&before); + let file = SourceFile::parse(&before); + if let Some(result) = on_dot_typed(&file, offset) { + let actual = result.edit.apply(&before); + assert_eq_text!(after, &actual); + } else { + assert_eq_text!(&before, after) + }; + } + + #[test] + fn indents_new_chain_call() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + . + } + ", + ) + } + + #[test] + fn indents_new_chain_call_with_semi() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|>; + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .; + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|>; + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .; + } + ", + ) + } + + #[test] + fn indents_continued_chain_call() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + . + } + ", + ); + } + + #[test] + fn indents_middle_of_chain_call() { + type_dot( + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + <|> + .nth(92) + .unwrap(); + } + ", + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + . + .nth(92) + .unwrap(); + } + ", + ); + type_dot( + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + <|> + .nth(92) + .unwrap(); + } + ", + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + . + .nth(92) + .unwrap(); + } + ", + ); + } + + #[test] + fn dont_indent_freestanding_dot() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + . + } + ", + ); + } + + #[test] + fn test_on_enter() { + fn apply_on_enter(before: &str) -> Option { + let (offset, before) = extract_offset(before); + let file = SourceFile::parse(&before); + let result = on_enter(&file, offset)?; + let actual = result.edit.apply(&before); + let actual = add_cursor(&actual, result.cursor_position.unwrap()); + Some(actual) + } + + fn do_check(before: &str, after: &str) { + let actual = apply_on_enter(before).unwrap(); + assert_eq_text!(after, &actual); + } + + fn do_check_noop(text: &str) { + assert!(apply_on_enter(text).is_none()) + } + + do_check( + r" +/// Some docs<|> +fn foo() { +} +", + r" +/// Some docs +/// <|> +fn foo() { +} +", + ); + do_check( + r" +impl S { + /// Some<|> docs. + fn foo() {} +} +", + r" +impl S { + /// Some + /// <|> docs. + fn foo() {} +} +", + ); + do_check_noop(r"<|>//! docz"); + } +} diff --git a/crates/ra_ide_api_light/src/lib.rs b/crates/ra_ide_api_light/src/lib.rs index f21a91e18..0d928745f 100644 --- a/crates/ra_ide_api_light/src/lib.rs +++ b/crates/ra_ide_api_light/src/lib.rs @@ -4,10 +4,8 @@ //! an edit or some auxiliary info. mod structure; -mod typing; use rustc_hash::FxHashSet; -use ra_text_edit::TextEditBuilder; use ra_syntax::{ SourceFile, SyntaxNode, TextRange, TextUnit, Direction, algo::find_leaf_at_offset, @@ -17,7 +15,6 @@ use ra_syntax::{ pub use crate::{ structure::{file_structure, StructureNode}, - typing::{on_enter, on_dot_typed, on_eq_typed}, }; #[derive(Debug)] diff --git a/crates/ra_ide_api_light/src/typing.rs b/crates/ra_ide_api_light/src/typing.rs deleted file mode 100644 index c69270333..000000000 --- a/crates/ra_ide_api_light/src/typing.rs +++ /dev/null @@ -1,407 +0,0 @@ -use ra_syntax::{ - AstNode, SourceFile, SyntaxKind::*, - SyntaxNode, TextUnit, TextRange, - algo::{find_node_at_offset, find_leaf_at_offset, LeafAtOffset}, - ast::{self, AstToken}, -}; -use ra_fmt::leading_indent; -use crate::{LocalEdit, TextEditBuilder}; - -pub fn on_enter(file: &SourceFile, offset: TextUnit) -> Option { - let comment = - find_leaf_at_offset(file.syntax(), offset).left_biased().and_then(ast::Comment::cast)?; - - if let ast::CommentFlavor::Multiline = comment.flavor() { - return None; - } - - let prefix = comment.prefix(); - if offset < comment.syntax().range().start() + TextUnit::of_str(prefix) + TextUnit::from(1) { - return None; - } - - let indent = node_indent(file, comment.syntax())?; - let inserted = format!("\n{}{} ", indent, prefix); - let cursor_position = offset + TextUnit::of_str(&inserted); - let mut edit = TextEditBuilder::default(); - edit.insert(offset, inserted); - Some(LocalEdit { - label: "on enter".to_string(), - edit: edit.finish(), - cursor_position: Some(cursor_position), - }) -} - -fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> { - let ws = match find_leaf_at_offset(file.syntax(), node.range().start()) { - LeafAtOffset::Between(l, r) => { - assert!(r == node); - l - } - LeafAtOffset::Single(n) => { - assert!(n == node); - return Some(""); - } - LeafAtOffset::None => unreachable!(), - }; - if ws.kind() != WHITESPACE { - return None; - } - let text = ws.leaf_text().unwrap(); - let pos = text.as_str().rfind('\n').map(|it| it + 1).unwrap_or(0); - Some(&text[pos..]) -} - -pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option { - assert_eq!(file.syntax().text().char_at(eq_offset), Some('=')); - let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?; - if let_stmt.has_semi() { - return None; - } - if let Some(expr) = let_stmt.initializer() { - let expr_range = expr.syntax().range(); - if expr_range.contains(eq_offset) && eq_offset != expr_range.start() { - return None; - } - if file.syntax().text().slice(eq_offset..expr_range.start()).contains('\n') { - return None; - } - } else { - return None; - } - let offset = let_stmt.syntax().range().end(); - let mut edit = TextEditBuilder::default(); - edit.insert(offset, ";".to_string()); - Some(LocalEdit { - label: "add semicolon".to_string(), - edit: edit.finish(), - cursor_position: None, - }) -} - -pub fn on_dot_typed(file: &SourceFile, dot_offset: TextUnit) -> Option { - assert_eq!(file.syntax().text().char_at(dot_offset), Some('.')); - - let whitespace = find_leaf_at_offset(file.syntax(), dot_offset) - .left_biased() - .and_then(ast::Whitespace::cast)?; - - let current_indent = { - let text = whitespace.text(); - let newline = text.rfind('\n')?; - &text[newline + 1..] - }; - let current_indent_len = TextUnit::of_str(current_indent); - - // Make sure dot is a part of call chain - let field_expr = whitespace.syntax().parent().and_then(ast::FieldExpr::cast)?; - let prev_indent = leading_indent(field_expr.syntax())?; - let target_indent = format!(" {}", prev_indent); - let target_indent_len = TextUnit::of_str(&target_indent); - if current_indent_len == target_indent_len { - return None; - } - let mut edit = TextEditBuilder::default(); - edit.replace( - TextRange::from_to(dot_offset - current_indent_len, dot_offset), - target_indent.into(), - ); - let res = LocalEdit { - label: "reindent dot".to_string(), - edit: edit.finish(), - cursor_position: Some( - dot_offset + target_indent_len - current_indent_len + TextUnit::of_char('.'), - ), - }; - Some(res) -} - -#[cfg(test)] -mod tests { - use test_utils::{add_cursor, assert_eq_text, extract_offset}; - - use super::*; - - #[test] - fn test_on_eq_typed() { - fn type_eq(before: &str, after: &str) { - let (offset, before) = extract_offset(before); - let mut edit = TextEditBuilder::default(); - edit.insert(offset, "=".to_string()); - let before = edit.finish().apply(&before); - let file = SourceFile::parse(&before); - if let Some(result) = on_eq_typed(&file, offset) { - let actual = result.edit.apply(&before); - assert_eq_text!(after, &actual); - } else { - assert_eq_text!(&before, after) - }; - } - - // do_check(r" - // fn foo() { - // let foo =<|> - // } - // ", r" - // fn foo() { - // let foo =; - // } - // "); - type_eq( - r" -fn foo() { - let foo <|> 1 + 1 -} -", - r" -fn foo() { - let foo = 1 + 1; -} -", - ); - // do_check(r" - // fn foo() { - // let foo =<|> - // let bar = 1; - // } - // ", r" - // fn foo() { - // let foo =; - // let bar = 1; - // } - // "); - } - - fn type_dot(before: &str, after: &str) { - let (offset, before) = extract_offset(before); - let mut edit = TextEditBuilder::default(); - edit.insert(offset, ".".to_string()); - let before = edit.finish().apply(&before); - let file = SourceFile::parse(&before); - if let Some(result) = on_dot_typed(&file, offset) { - let actual = result.edit.apply(&before); - assert_eq_text!(after, &actual); - } else { - assert_eq_text!(&before, after) - }; - } - - #[test] - fn indents_new_chain_call() { - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - . - } - ", - ); - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - . - } - ", - ) - } - - #[test] - fn indents_new_chain_call_with_semi() { - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - <|>; - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .; - } - ", - ); - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - <|>; - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .; - } - ", - ) - } - - #[test] - fn indents_continued_chain_call() { - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .first() - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .first() - . - } - ", - ); - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .first() - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - self.child_impl(db, name) - .first() - . - } - ", - ); - } - - #[test] - fn indents_middle_of_chain_call() { - type_dot( - r" - fn source_impl() { - let var = enum_defvariant_list().unwrap() - <|> - .nth(92) - .unwrap(); - } - ", - r" - fn source_impl() { - let var = enum_defvariant_list().unwrap() - . - .nth(92) - .unwrap(); - } - ", - ); - type_dot( - r" - fn source_impl() { - let var = enum_defvariant_list().unwrap() - <|> - .nth(92) - .unwrap(); - } - ", - r" - fn source_impl() { - let var = enum_defvariant_list().unwrap() - . - .nth(92) - .unwrap(); - } - ", - ); - } - - #[test] - fn dont_indent_freestanding_dot() { - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - . - } - ", - ); - type_dot( - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - <|> - } - ", - r" - pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - . - } - ", - ); - } - - #[test] - fn test_on_enter() { - fn apply_on_enter(before: &str) -> Option { - let (offset, before) = extract_offset(before); - let file = SourceFile::parse(&before); - let result = on_enter(&file, offset)?; - let actual = result.edit.apply(&before); - let actual = add_cursor(&actual, result.cursor_position.unwrap()); - Some(actual) - } - - fn do_check(before: &str, after: &str) { - let actual = apply_on_enter(before).unwrap(); - assert_eq_text!(after, &actual); - } - - fn do_check_noop(text: &str) { - assert!(apply_on_enter(text).is_none()) - } - - do_check( - r" -/// Some docs<|> -fn foo() { -} -", - r" -/// Some docs -/// <|> -fn foo() { -} -", - ); - do_check( - r" -impl S { - /// Some<|> docs. - fn foo() {} -} -", - r" -impl S { - /// Some - /// <|> docs. - fn foo() {} -} -", - ); - do_check_noop(r"<|>//! docz"); - } -} -- cgit v1.2.3