1 files changed, 314 insertions, 34 deletions

diff --git a/crates/ide/src/move_item.rs b/crates/ide/src/move_item.rs
index 05fa8fc13..246f10a0a 100644
--- a/crates/ide/src/move_item.rs
+++ b/crates/ide/src/move_item.rs
@@ -1,13 +1,15 @@
-use std::iter::once;
+use std::{iter::once, mem};
 
 use hir::Semantics;
 use ide_db::{base_db::FileRange, RootDatabase};
 use itertools::Itertools;
 use syntax::{
-    algo, ast, match_ast, AstNode, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
+    algo, ast, match_ast, AstNode, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange,
+    TokenAtOffset,
 };
 use text_edit::{TextEdit, TextEditBuilder};
 
+#[derive(Copy, Clone, Debug)]
 pub enum Direction {
     Up,
     Down,
@@ -23,6 +25,8 @@ pub enum Direction {
 // | VS Code | **Rust Analyzer: Move item up**
 // | VS Code | **Rust Analyzer: Move item down**
 // |===
+//
+// image::https://user-images.githubusercontent.com/48062697/113065576-04298180-91b1-11eb-91ce-4505e99ed598.gif[]
 pub(crate) fn move_item(
     db: &RootDatabase,
     range: FileRange,
@@ -31,14 +35,19 @@ pub(crate) fn move_item(
     let sema = Semantics::new(db);
     let file = sema.parse(range.file_id);
 
-    let item = file.syntax().covering_element(range.range);
+    let item = if range.range.is_empty() {
+        SyntaxElement::Token(pick_best(file.syntax().token_at_offset(range.range.start()))?)
+    } else {
+        file.syntax().covering_element(range.range)
+    };
+
     find_ancestors(item, direction, range.range)
 }
 
 fn find_ancestors(item: SyntaxElement, direction: Direction, range: TextRange) -> Option<TextEdit> {
     let root = match item {
-        NodeOrToken::Node(node) => node,
-        NodeOrToken::Token(token) => token.parent()?,
+        SyntaxElement::Node(node) => node,
+        SyntaxElement::Token(token) => token.parent()?,
     };
 
     let movable = [
@@ -51,6 +60,11 @@ fn find_ancestors(item: SyntaxElement, direction: Direction, range: TextRange) -
         SyntaxKind::PARAM,
         SyntaxKind::LET_STMT,
         SyntaxKind::EXPR_STMT,
+        SyntaxKind::IF_EXPR,
+        SyntaxKind::FOR_EXPR,
+        SyntaxKind::LOOP_EXPR,
+        SyntaxKind::WHILE_EXPR,
+        SyntaxKind::RETURN_EXPR,
         SyntaxKind::MATCH_EXPR,
         SyntaxKind::MACRO_CALL,
         SyntaxKind::TYPE_ALIAS,
@@ -83,12 +97,12 @@ fn move_in_direction(
 ) -> Option<TextEdit> {
     match_ast! {
         match node {
-            ast::ArgList(it) => swap_sibling_in_list(it.args(), range, direction),
-            ast::GenericParamList(it) => swap_sibling_in_list(it.generic_params(), range, direction),
-            ast::GenericArgList(it) => swap_sibling_in_list(it.generic_args(), range, direction),
-            ast::VariantList(it) => swap_sibling_in_list(it.variants(), range, direction),
-            ast::TypeBoundList(it) => swap_sibling_in_list(it.bounds(), range, direction),
-            _ => Some(replace_nodes(node, &match direction {
+            ast::ArgList(it) => swap_sibling_in_list(node, it.args(), range, direction),
+            ast::GenericParamList(it) => swap_sibling_in_list(node, it.generic_params(), range, direction),
+            ast::GenericArgList(it) => swap_sibling_in_list(node, it.generic_args(), range, direction),
+            ast::VariantList(it) => swap_sibling_in_list(node, it.variants(), range, direction),
+            ast::TypeBoundList(it) => swap_sibling_in_list(node, it.bounds(), range, direction),
+            _ => Some(replace_nodes(range, node, &match direction {
                 Direction::Up => node.prev_sibling(),
                 Direction::Down => node.next_sibling(),
             }?))
@@ -97,30 +111,77 @@ fn move_in_direction(
 }
 
 fn swap_sibling_in_list<A: AstNode + Clone, I: Iterator<Item = A>>(
+    node: &SyntaxNode,
     list: I,
     range: TextRange,
     direction: Direction,
 ) -> Option<TextEdit> {
-    let (l, r) = list
+    let list_lookup = list
         .tuple_windows()
         .filter(|(l, r)| match direction {
             Direction::Up => r.syntax().text_range().contains_range(range),
             Direction::Down => l.syntax().text_range().contains_range(range),
         })
-        .next()?;
-
-    Some(replace_nodes(l.syntax(), r.syntax()))
+        .next();
+
+    if let Some((l, r)) = list_lookup {
+        Some(replace_nodes(range, l.syntax(), r.syntax()))
+    } else {
+        // Cursor is beyond any movable list item (for example, on curly brace in enum).
+        // It's not necessary, that parent of list is movable (arg list's parent is not, for example),
+        // and we have to continue tree traversal to find suitable node.
+        find_ancestors(SyntaxElement::Node(node.parent()?), direction, range)
+    }
 }
 
-fn replace_nodes(first: &SyntaxNode, second: &SyntaxNode) -> TextEdit {
+fn replace_nodes<'a>(
+    range: TextRange,
+    mut first: &'a SyntaxNode,
+    mut second: &'a SyntaxNode,
+) -> TextEdit {
+    let cursor_offset = if range.is_empty() {
+        // FIXME: `applySnippetTextEdits` does not support non-empty selection ranges
+        if first.text_range().contains_range(range) {
+            Some(range.start() - first.text_range().start())
+        } else if second.text_range().contains_range(range) {
+            mem::swap(&mut first, &mut second);
+            Some(range.start() - first.text_range().start())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let first_with_cursor = match cursor_offset {
+        Some(offset) => {
+            let mut item_text = first.text().to_string();
+            item_text.insert_str(offset.into(), "$0");
+            item_text
+        }
+        None => first.text().to_string(),
+    };
+
     let mut edit = TextEditBuilder::default();
 
     algo::diff(first, second).into_text_edit(&mut edit);
-    algo::diff(second, first).into_text_edit(&mut edit);
+    edit.replace(second.text_range(), first_with_cursor);
 
     edit.finish()
 }
 
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            SyntaxKind::IDENT | SyntaxKind::LIFETIME_IDENT => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::fixture;
@@ -154,7 +215,7 @@ fn main() {
             expect![[r#"
 fn main() {
     match true {
-        false => {
+        false =>$0 {
             println!("Test");
         },
         true => {
@@ -188,7 +249,7 @@ fn main() {
         false => {
             println!("Test");
         },
-        true => {
+        true =>$0 {
             println!("Hello, world");
         }
     };
@@ -240,7 +301,7 @@ fn main() {
             "#,
             expect![[r#"
 fn main() {
-    let test2 = 456;
+    let test2$0 = 456;
     let test = 123;
 }
             "#]],
@@ -259,7 +320,108 @@ fn main() {
             "#,
             expect![[r#"
 fn main() {
-    println!("All I want to say is...");
+    println!("All I want to say is...");$0
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+
+    if true {
+        println!("Test");
+    }$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    if true {
+        println!("Test");
+    }$0
+
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+
+    for i in 0..10 {
+        println!("Test");
+    }$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    for i in 0..10 {
+        println!("Test");
+    }$0
+
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+
+    loop {
+        println!("Test");
+    }$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    loop {
+        println!("Test");
+    }$0
+
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+
+    while true {
+        println!("Test");
+    }$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    while true {
+        println!("Test");
+    }$0
+
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+
+    return 123;$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    return 123;$0
+
     println!("Hello, world");
 }
             "#]],
@@ -295,7 +457,7 @@ fn main() {}
 fn foo() {}$0$0
             "#,
             expect![[r#"
-fn foo() {}
+fn foo() {}$0
 
 fn main() {}
             "#]],
@@ -316,7 +478,7 @@ impl Wow for Yay $0$0{}
             expect![[r#"
 struct Yay;
 
-impl Wow for Yay {}
+impl Wow for Yay $0{}
 
 trait Wow {}
             "#]],
@@ -332,7 +494,7 @@ use std::vec::Vec;
 use std::collections::HashMap$0$0;
             "#,
             expect![[r#"
-use std::collections::HashMap;
+use std::collections::HashMap$0;
 use std::vec::Vec;
             "#]],
             Direction::Up,
@@ -367,7 +529,7 @@ fn main() {
     }
 
     #[test]
-    fn test_moves_param_up() {
+    fn test_moves_param() {
         check(
             r#"
 fn test(one: i32, two$0$0: u32) {}
@@ -377,7 +539,7 @@ fn main() {
 }
             "#,
             expect![[r#"
-fn test(two: u32, one: i32) {}
+fn test(two$0: u32, one: i32) {}
 
 fn main() {
     test(123, 456);
@@ -385,6 +547,15 @@ fn main() {
             "#]],
             Direction::Up,
         );
+        check(
+            r#"
+fn f($0$0arg: u8, arg2: u16) {}
+            "#,
+            expect![[r#"
+fn f(arg2: u16, $0arg: u8) {}
+            "#]],
+            Direction::Down,
+        );
     }
 
     #[test]
@@ -401,7 +572,7 @@ fn main() {
 fn test(one: i32, two: u32) {}
 
 fn main() {
-    test(456, 123);
+    test(456$0, 123);
 }
             "#]],
             Direction::Up,
@@ -422,7 +593,7 @@ fn main() {
 fn test(one: i32, two: u32) {}
 
 fn main() {
-    test(456, 123);
+    test(456, 123$0);
 }
             "#]],
             Direction::Down,
@@ -459,7 +630,7 @@ struct Test<A, B$0$0>(A, B);
 fn main() {}
             "#,
             expect![[r#"
-struct Test<B, A>(A, B);
+struct Test<B$0, A>(A, B);
 
 fn main() {}
             "#]],
@@ -481,7 +652,7 @@ fn main() {
 struct Test<A, B>(A, B);
 
 fn main() {
-    let t = Test::<&str, i32>(123, "yay");
+    let t = Test::<&str$0, i32>(123, "yay");
 }
             "#]],
             Direction::Up,
@@ -501,7 +672,7 @@ fn main() {}
             "#,
             expect![[r#"
 enum Hello {
-    Two,
+    Two$0,
     One
 }
 
@@ -528,7 +699,7 @@ trait One {}
 
 trait Two {}
 
-fn test<T: Two + One>(t: T) {}
+fn test<T: Two$0 + One>(t: T) {}
 
 fn main() {}
             "#]],
@@ -574,7 +745,7 @@ trait Yay {
 impl Yay for Test {
     type One = i32;
 
-    fn inner() {
+    fn inner() {$0
         println!("Mmmm");
     }
 
@@ -601,7 +772,7 @@ fn test() {
             "#,
             expect![[r#"
 fn test() {
-    mod hi {
+    mod hi {$0
         fn inner() {}
     }
 
@@ -615,6 +786,115 @@ fn test() {
     }
 
     #[test]
+    fn test_cursor_at_item_start() {
+        check(
+            r#"
+$0$0#[derive(Debug)]
+enum FooBar {
+    Foo,
+    Bar,
+}
+
+fn main() {}
+            "#,
+            expect![[r#"
+fn main() {}
+
+$0#[derive(Debug)]
+enum FooBar {
+    Foo,
+    Bar,
+}
+            "#]],
+            Direction::Down,
+        );
+        check(
+            r#"
+$0$0enum FooBar {
+    Foo,
+    Bar,
+}
+
+fn main() {}
+            "#,
+            expect![[r#"
+fn main() {}
+
+$0enum FooBar {
+    Foo,
+    Bar,
+}
+            "#]],
+            Direction::Down,
+        );
+        check(
+            r#"
+struct Test;
+
+trait SomeTrait {}
+
+$0$0impl SomeTrait for Test {}
+
+fn main() {}
+            "#,
+            expect![[r#"
+struct Test;
+
+$0impl SomeTrait for Test {}
+
+trait SomeTrait {}
+
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+
+    #[test]
+    fn test_cursor_at_item_end() {
+        check(
+            r#"
+enum FooBar {
+    Foo,
+    Bar,
+}$0$0
+
+fn main() {}
+            "#,
+            expect![[r#"
+fn main() {}
+
+enum FooBar {
+    Foo,
+    Bar,
+}$0
+            "#]],
+            Direction::Down,
+        );
+        check(
+            r#"
+struct Test;
+
+trait SomeTrait {}
+
+impl SomeTrait for Test {}$0$0
+
+fn main() {}
+            "#,
+            expect![[r#"
+struct Test;
+
+impl SomeTrait for Test {}$0
+
+trait SomeTrait {}
+
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+
+    #[test]
     fn handles_empty_file() {
         check(r#"$0$0"#, expect![[r#""#]], Direction::Up);
     }