5 files changed, 217 insertions, 11 deletions

diff --git a/crates/ra_assists/src/assists/flip_trait_bound.rs b/crates/ra_assists/src/assists/flip_trait_bound.rs
new file mode 100644
index 000000000..1625b241f
--- /dev/null
+++ b/crates/ra_assists/src/assists/flip_trait_bound.rs
@@ -0,0 +1,119 @@
+use hir::db::HirDatabase;
+use ra_syntax::{
+    algo::non_trivia_sibling,
+    ast::{self, AstNode},
+    Direction, T,
+};
+
+use crate::{Assist, AssistCtx, AssistId};
+
+// Assist: flip_trait_bound
+//
+// Flips two trait bounds.
+//
+// ```
+// fn foo<T: Clone +<|> Copy>() { }
+// ```
+// ->
+// ```
+// fn foo<T: Copy + Clone>() { }
+// ```
+pub(crate) fn flip_trait_bound(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    // We want to replicate the behavior of `flip_binexpr` by only suggesting
+    // the assist when the cursor is on a `+`
+    let plus = ctx.find_token_at_offset(T![+])?;
+
+    // Make sure we're in a `TypeBoundList`
+    if ast::TypeBoundList::cast(plus.parent()).is_none() {
+        return None;
+    }
+
+    let (before, after) = (
+        non_trivia_sibling(plus.clone().into(), Direction::Prev)?,
+        non_trivia_sibling(plus.clone().into(), Direction::Next)?,
+    );
+
+    ctx.add_action(AssistId("flip_trait_bound"), "flip trait bound", |edit| {
+        edit.target(plus.text_range());
+        edit.replace(before.text_range(), after.to_string());
+        edit.replace(after.text_range(), before.to_string());
+    });
+
+    ctx.build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    #[test]
+    fn flip_trait_bound_assist_available() {
+        check_assist_target(flip_trait_bound, "struct S<T> where T: A <|>+ B + C { }", "+")
+    }
+
+    #[test]
+    fn flip_trait_bound_not_applicable_for_single_trait_bound() {
+        check_assist_not_applicable(flip_trait_bound, "struct S<T> where T: <|>A { }")
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_struct() {
+        check_assist(
+            flip_trait_bound,
+            "struct S<T> where T: A <|>+ B { }",
+            "struct S<T> where T: B <|>+ A { }",
+        )
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_trait_impl() {
+        check_assist(
+            flip_trait_bound,
+            "impl X for S<T> where T: A +<|> B { }",
+            "impl X for S<T> where T: B +<|> A { }",
+        )
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_fn() {
+        check_assist(flip_trait_bound, "fn f<T: A <|>+ B>(t: T) { }", "fn f<T: B <|>+ A>(t: T) { }")
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_fn_where_clause() {
+        check_assist(
+            flip_trait_bound,
+            "fn f<T>(t: T) where T: A +<|> B { }",
+            "fn f<T>(t: T) where T: B +<|> A { }",
+        )
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_lifetime() {
+        check_assist(
+            flip_trait_bound,
+            "fn f<T>(t: T) where T: A <|>+ 'static { }",
+            "fn f<T>(t: T) where T: 'static <|>+ A { }",
+        )
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_complex_bounds() {
+        check_assist(
+            flip_trait_bound,
+            "struct S<T> where T: A<T> <|>+ b_mod::B<T> + C<T> { }",
+            "struct S<T> where T: b_mod::B<T> <|>+ A<T> + C<T> { }",
+        )
+    }
+
+    #[test]
+    fn flip_trait_bound_works_for_long_bounds() {
+        check_assist(
+            flip_trait_bound,
+            "struct S<T> where T: A + B + C + D + E + F +<|> G + H + I + J { }",
+            "struct S<T> where T: A + B + C + D + E + G +<|> F + H + I + J { }",
+        )
+    }
+}
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index 0ccf9d730..6e1e3de84 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -17,7 +17,17 @@ fn check(assist_id: &str, before: &str, after: &str) {
     let (_assist_id, action) = crate::assists(&db, frange)
         .into_iter()
         .find(|(id, _)| id.id.0 == assist_id)
-        .unwrap_or_else(|| panic!("Assist {:?} is not applicable", assist_id));
+        .unwrap_or_else(|| {
+            panic!(
+                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
+                assist_id,
+                crate::assists(&db, frange)
+                    .into_iter()
+                    .map(|(id, _)| id.id.0)
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        });
 
     let actual = action.edit.apply(&before);
     assert_eq_text!(after, &actual);
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index b8d335911..ebe49aecf 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -256,6 +256,19 @@ fn main() {
 }
 
 #[test]
+fn doctest_flip_trait_bound() {
+    check(
+        "flip_trait_bound",
+        r#####"
+fn foo<T: Clone +<|> Copy>() { }
+"#####,
+        r#####"
+fn foo<T: Copy + Clone>() { }
+"#####,
+    )
+}
+
+#[test]
 fn doctest_inline_local_variable() {
     check(
         "inline_local_variable",
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 7c226572a..7a1657d87 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -97,6 +97,7 @@ mod assists {
     mod apply_demorgan;
     mod flip_comma;
     mod flip_binexpr;
+    mod flip_trait_bound;
     mod change_visibility;
     mod fill_match_arms;
     mod merge_match_arms;
@@ -123,6 +124,7 @@ mod assists {
             merge_match_arms::merge_match_arms,
             flip_comma::flip_comma,
             flip_binexpr::flip_binexpr,
+            flip_trait_bound::flip_trait_bound,
             introduce_variable::introduce_variable,
             replace_if_let_with_match::replace_if_let_with_match,
             split_import::split_import,
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index 602757e92..4b7bfc0b1 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
     algo::find_covering_element,
     ast::{self, AstNode, AstToken},
     Direction, NodeOrToken,
-    SyntaxKind::*,
+    SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, TextRange, TextUnit, TokenAtOffset, T,
 };
 
@@ -29,10 +29,12 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
         USE_TREE_LIST,
         TYPE_PARAM_LIST,
         TYPE_ARG_LIST,
+        TYPE_BOUND_LIST,
         PARAM_LIST,
         ARG_LIST,
         ARRAY_EXPR,
         TUPLE_EXPR,
+        WHERE_CLAUSE,
     ];
 
     if range.is_empty() {
@@ -146,13 +148,17 @@ fn pick_best<'a>(l: SyntaxToken, r: SyntaxToken) -> SyntaxToken {
     }
 }
 
-/// Extend list item selection to include nearby comma and whitespace.
+/// Extend list item selection to include nearby delimiter and whitespace.
 fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
     fn is_single_line_ws(node: &SyntaxToken) -> bool {
         node.kind() == WHITESPACE && !node.text().contains('\n')
     }
 
-    fn nearby_comma(node: &SyntaxNode, dir: Direction) -> Option<SyntaxToken> {
+    fn nearby_delimiter(
+        delimiter_kind: SyntaxKind,
+        node: &SyntaxNode,
+        dir: Direction,
+    ) -> Option<SyntaxToken> {
         node.siblings_with_tokens(dir)
             .skip(1)
             .skip_while(|node| match node {
@@ -161,19 +167,26 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
             })
             .next()
             .and_then(|it| it.into_token())
-            .filter(|node| node.kind() == T![,])
+            .filter(|node| node.kind() == delimiter_kind)
     }
 
-    if let Some(comma_node) = nearby_comma(node, Direction::Prev) {
-        return Some(TextRange::from_to(comma_node.text_range().start(), node.text_range().end()));
+    let delimiter = match node.kind() {
+        TYPE_BOUND => T![+],
+        _ => T![,],
+    };
+    if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Prev) {
+        return Some(TextRange::from_to(
+            delimiter_node.text_range().start(),
+            node.text_range().end(),
+        ));
     }
-    if let Some(comma_node) = nearby_comma(node, Direction::Next) {
-        // Include any following whitespace when comma if after list item.
-        let final_node = comma_node
+    if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Next) {
+        // Include any following whitespace when delimiter is after list item.
+        let final_node = delimiter_node
             .next_sibling_or_token()
             .and_then(|it| it.into_token())
             .filter(|node| is_single_line_ws(node))
-            .unwrap_or(comma_node);
+            .unwrap_or(delimiter_node);
 
         return Some(TextRange::from_to(node.text_range().start(), final_node.text_range().end()));
     }
@@ -387,4 +400,53 @@ fn bar(){}
             &["foo", "\" fn foo() {\""],
         );
     }
+
+    #[test]
+    fn test_extend_trait_bounds_list_in_where_clause() {
+        do_check(
+            r#"
+fn foo<R>() 
+    where 
+        R: req::Request + 'static,
+        R::Params: DeserializeOwned<|> + panic::UnwindSafe + 'static,
+        R::Result: Serialize + 'static,
+"#,
+            &[
+                "DeserializeOwned",
+                "DeserializeOwned + ",
+                "DeserializeOwned + panic::UnwindSafe + 'static",
+                "R::Params: DeserializeOwned + panic::UnwindSafe + 'static",
+                "R::Params: DeserializeOwned + panic::UnwindSafe + 'static,",
+            ],
+        );
+        do_check(r#"fn foo<T>() where T: <|>Copy"#, &["Copy"]);
+        do_check(r#"fn foo<T>() where T: <|>Copy + Display"#, &["Copy", "Copy + "]);
+        do_check(r#"fn foo<T>() where T: <|>Copy +Display"#, &["Copy", "Copy +"]);
+        do_check(r#"fn foo<T>() where T: <|>Copy+Display"#, &["Copy", "Copy+"]);
+        do_check(r#"fn foo<T>() where T: Copy + <|>Display"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T>() where T: Copy + <|>Display + Sync"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T>() where T: Copy +<|>Display"#, &["Display", "+Display"]);
+    }
+
+    #[test]
+    fn test_extend_trait_bounds_list_inline() {
+        do_check(r#"fn foo<T: <|>Copy>() {}"#, &["Copy"]);
+        do_check(r#"fn foo<T: <|>Copy + Display>() {}"#, &["Copy", "Copy + "]);
+        do_check(r#"fn foo<T: <|>Copy +Display>() {}"#, &["Copy", "Copy +"]);
+        do_check(r#"fn foo<T: <|>Copy+Display>() {}"#, &["Copy", "Copy+"]);
+        do_check(r#"fn foo<T: Copy + <|>Display>() {}"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T: Copy + <|>Display + Sync>() {}"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T: Copy +<|>Display>() {}"#, &["Display", "+Display"]);
+        do_check(
+            r#"fn foo<T: Copy<|> + Display, U: Copy>() {}"#,
+            &[
+                "Copy",
+                "Copy + ",
+                "Copy + Display",
+                "T: Copy + Display",
+                "T: Copy + Display, ",
+                "<T: Copy + Display, U: Copy>",
+            ],
+        );
+    }
 }