Merge #442

442: WIP: indent on typing dot r=matklad a=simonvandel

Fixes #439.

The unit test passes, but I can't seem to make VS code perform the action. The existing action on "=" doesn't work either on my end either though.

I didn't add any smart way of detecting the current indent level. Any ideas how I would do that?

Co-authored-by: Simon Vandel Sillesen <[email protected]>

1 files changed, 165 insertions, 4 deletions

diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 1b568e96c..12500854c 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -1,17 +1,17 @@
 use std::mem;
 
+use itertools::Itertools;
 use ra_syntax::{
     algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
     ast,
     text_utils::intersect,
-    AstNode, SourceFileNode, SyntaxKind,
+    AstNode, Direction, SourceFileNode, SyntaxKind,
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
 use ra_text_edit::text_utils::contains_offset_nonstrict;
-use itertools::Itertools;
 
-use crate::{find_node_at_offset, TextEditBuilder, LocalEdit};
+use crate::{find_node_at_offset, LocalEdit, TextEditBuilder};
 
 pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
     let range = if range.is_empty() {
@@ -136,6 +136,56 @@ pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit>
     })
 }
 
+pub fn on_dot_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
+    let before_dot_offset = offset - TextUnit::of_char('.');
+
+    let whitespace = find_leaf_at_offset(file.syntax(), before_dot_offset).left_biased()?;
+
+    // find whitespace just left of the dot
+    ast::Whitespace::cast(whitespace)?;
+
+    // make sure there is a method call
+    let method_call = whitespace
+        .siblings(Direction::Prev)
+        // first is whitespace
+        .skip(1)
+        .next()?;
+
+    ast::MethodCallExprNode::cast(method_call)?;
+
+    // find how much the _method call is indented
+    let method_chain_indent = method_call
+        .parent()?
+        .siblings(Direction::Prev)
+        .skip(1)
+        .next()?
+        .leaf_text()
+        .map(|x| last_line_indent_in_whitespace(x))?;
+
+    let current_indent = TextUnit::of_str(last_line_indent_in_whitespace(whitespace.leaf_text()?));
+    // TODO: indent is always 4 spaces now. A better heuristic could look on the previous line(s)
+
+    let target_indent = TextUnit::of_str(method_chain_indent) + TextUnit::from_usize(4);
+
+    let diff = target_indent - current_indent;
+
+    let indent = "".repeat(diff.to_usize());
+
+    let cursor_position = offset + diff;
+    let mut edit = TextEditBuilder::default();
+    edit.insert(before_dot_offset, indent);
+    Some(LocalEdit {
+        label: "indent dot".to_string(),
+        edit: edit.finish(),
+        cursor_position: Some(cursor_position),
+    })
+}
+
+/// Finds the last line in the whitespace
+fn last_line_indent_in_whitespace(ws: &str) -> &str {
+    ws.split('\n').last().unwrap_or("")
+}
+
 fn remove_newline(
     edit: &mut TextEditBuilder,
     node: SyntaxNodeRef,
@@ -283,7 +333,9 @@ fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{add_cursor, check_action, extract_offset, extract_range, assert_eq_text};
+    use crate::test_utils::{
+        add_cursor, assert_eq_text, check_action, extract_offset, extract_range,
+};
 
     fn check_join_lines(before: &str, after: &str) {
         check_action(before, after, |file, offset| {
@@ -615,6 +667,115 @@ fn foo() {
     }
 
     #[test]
+    fn test_on_dot_typed() {
+        fn do_check(before: &str, after: &str) {
+            let (offset, before) = extract_offset(before);
+            let file = SourceFileNode::parse(&before);
+            if let Some(result) = on_eq_typed(&file, offset) {
+                let actual = result.edit.apply(&before);
+                assert_eq_text!(after, &actual);
+            };
+        }
+        // indent if continuing chain call
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+        .<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .
+    }
+",
+        );
+
+        // do not indent if already indented
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .
+    }
+",
+        );
+
+        // indent if the previous line is already indented
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .first()
+        .<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .first()
+            .
+    }
+",
+        );
+
+        // don't indent if indent matches previous line
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .first()
+            .<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .first()
+            .
+    }
+",
+        );
+
+        // don't indent if there is no method call on previous line
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        .<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        .
+    }
+",
+        );
+
+        // indent to match previous expr
+        do_check(
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+.<|>
+    }
+",
+            r"
+    pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        self.child_impl(db, name)
+            .
+    }
+",
+        );
+    }
+
+    #[test]
     fn test_on_enter() {
         fn apply_on_enter(before: &str) -> Option<String> {
             let (offset, before) = extract_offset(before);