3 files changed, 84 insertions, 40 deletions

diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index 1d78cb7e8..7615f37a6 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -12,6 +12,7 @@ use crate::{find_node_at_offset, TextEdit, TextEditBuilder};
 
 #[derive(Debug)]
 pub struct LocalEdit {
+    pub label: String,
     pub edit: TextEdit,
     pub cursor_position: Option<TextUnit>,
 }
@@ -30,6 +31,7 @@ pub fn flip_comma<'a>(
         edit.replace(prev.range(), next.text().to_string());
         edit.replace(next.range(), prev.text().to_string());
         LocalEdit {
+            label: "flip comma".to_string(),
             edit: edit.finish(),
             cursor_position: None,
         }
@@ -58,6 +60,7 @@ pub fn add_derive<'a>(
             Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
         };
         LocalEdit {
+            label: "add `#[derive]`".to_string(),
             edit: edit.finish(),
             cursor_position: Some(offset),
         }
@@ -109,6 +112,7 @@ pub fn add_impl<'a>(
         buf.push_str("\n}");
         edit.insert(start_offset, buf);
         LocalEdit {
+            label: "add impl".to_string(),
             edit: edit.finish(),
             cursor_position: Some(offset),
         }
@@ -148,6 +152,7 @@ pub fn introduce_variable<'a>(
         }
         let cursor_position = anchor_stmt.range().start() + TextUnit::of_str("let ");
         LocalEdit {
+            label: "introduce variable".to_string(),
             edit: edit.finish(),
             cursor_position: Some(cursor_position),
         }
@@ -194,6 +199,7 @@ pub fn make_pub_crate<'a>(
             || parent.children().any(|child| child.kind() == VISIBILITY)
         {
             return LocalEdit {
+                label: "make pub crate".to_string(),
                 edit: edit.finish(),
                 cursor_position: Some(offset),
             };
@@ -201,6 +207,7 @@ pub fn make_pub_crate<'a>(
 
         edit.insert(node_start, "pub(crate) ".to_string());
         LocalEdit {
+            label: "make pub crate".to_string(),
             edit: edit.finish(),
             cursor_position: Some(node_start),
         }
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index 619497f0b..d9b89155b 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -26,6 +26,7 @@ use ra_syntax::{
     SyntaxKind::{self, *},
     SyntaxNodeRef, TextRange, TextUnit,
 };
+use itertools::Itertools;
 
 #[derive(Debug)]
 pub struct HighlightedRange {
@@ -44,6 +45,7 @@ pub struct Diagnostic {
     pub range: TextRange,
     pub msg: String,
     pub severity: Severity,
+    pub fix: Option<LocalEdit>,
 }
 
 #[derive(Debug)]
@@ -113,6 +115,7 @@ pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
             range: location_to_range(err.location()),
             msg: format!("Syntax Error: {}", err),
             severity: Severity::Error,
+            fix: None,
         })
         .collect();
 
@@ -126,11 +129,28 @@ fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagn
     let mut diagnostics = Vec::new();
     for node in file.syntax().descendants() {
         if let Some(use_tree_list) = ast::UseTreeList::cast(node) {
-            if use_tree_list.use_trees().count() <= 1 {
+            if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
+                let range = use_tree_list.syntax().range();
+                let edit = text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
+                    single_use_tree,
+                )
+                .unwrap_or_else(|| {
+                    let to_replace = single_use_tree.syntax().text().to_string();
+                    let mut edit_builder = TextEditBuilder::new();
+                    edit_builder.delete(range);
+                    edit_builder.insert(range.start(), to_replace);
+                    edit_builder.finish()
+                });
+
                 diagnostics.push(Diagnostic {
-                    range: use_tree_list.syntax().range(),
+                    range: range,
                     msg: format!("Unnecessary braces in use statement"),
                     severity: Severity::WeakWarning,
+                    fix: Some(LocalEdit {
+                        label: "Remove unnecessary braces".to_string(),
+                        edit: edit,
+                        cursor_position: None,
+                    }),
                 })
             }
         }
@@ -139,6 +159,28 @@ fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagn
     diagnostics
 }
 
+fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
+    single_use_tree: ast::UseTree,
+) -> Option<TextEdit> {
+    let use_tree_list_node = single_use_tree.syntax().parent()?;
+    if single_use_tree
+        .path()?
+        .segment()?
+        .syntax()
+        .first_child()?
+        .kind()
+        == SyntaxKind::SELF_KW
+    {
+        let start = use_tree_list_node.prev_sibling()?.range().start();
+        let end = use_tree_list_node.range().end();
+        let range = TextRange::from_to(start, end);
+        let mut edit_builder = TextEditBuilder::new();
+        edit_builder.delete(range);
+        return Some(edit_builder.finish());
+    }
+    None
+}
+
 pub fn syntax_tree(file: &SourceFileNode) -> String {
     ::ra_syntax::utils::dump_tree(file.syntax())
 }
@@ -175,8 +217,9 @@ pub fn find_node_at_offset<'a, N: AstNode<'a>>(
 
 #[cfg(test)]
 mod tests {
+    use crate::test_utils::{add_cursor, assert_eq_dbg, assert_eq_text, extract_offset};
+
     use super::*;
-    use crate::test_utils::{add_cursor, assert_eq_dbg, extract_offset, assert_eq_text};
 
     #[test]
     fn test_highlighting() {
@@ -240,22 +283,31 @@ fn test_foo() {}
 
     #[test]
     fn test_check_unnecessary_braces_in_use_statement() {
-        let file = SourceFileNode::parse(
-            r#"
-use a;
-use {b};
-use a::{c};
-use a::{c, d::e};
-use a::{c, d::{e}};
-fn main() {}
-"#,
+        fn check_not_applicable(code: &str) {
+            let file = SourceFileNode::parse(code);
+            let diagnostics = check_unnecessary_braces_in_use_statement(&file);
+            assert!(diagnostics.is_empty());
+        }
+
+        fn check_apply(before: &str, after: &str) {
+            let file = SourceFileNode::parse(before);
+            let diagnostic = check_unnecessary_braces_in_use_statement(&file)
+                .pop()
+                .unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
+            let fix = diagnostic.fix.unwrap();
+            let actual = fix.edit.apply(&before);
+            assert_eq_text!(after, &actual);
+        }
+
+        check_not_applicable(
+            "
+            use a;
+            use a::{c, d::e};
+        ",
         );
-        let diagnostics = check_unnecessary_braces_in_use_statement(&file);
-        assert_eq_dbg(
-            r#"[Diagnostic { range: [12; 15), msg: "Unnecessary braces in use statement", severity: WeakWarning },
-                Diagnostic { range: [24; 27), msg: "Unnecessary braces in use statement", severity: WeakWarning },
-                Diagnostic { range: [61; 64), msg: "Unnecessary braces in use statement", severity: WeakWarning }]"#,
-            &diagnostics,
-        )
+        check_apply("use {b};", "use b;");
+        check_apply("use a::{c};", "use a::c;");
+        check_apply("use a::{self};", "use a;");
+        check_apply("use a::{c, d::{e}};", "use a::{c, d::e};");
     }
 }
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 5e412bcfa..21d068a7b 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -9,6 +9,7 @@ use ra_syntax::{
     SyntaxNodeRef, TextRange, TextUnit,
 };
 use ra_text_edit::text_utils::contains_offset_nonstrict;
+use itertools::Itertools;
 
 use crate::{find_node_at_offset, TextEditBuilder, LocalEdit};
 
@@ -19,6 +20,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
         let pos = match text.find('\n') {
             None => {
                 return LocalEdit {
+                    label: "join lines".to_string(),
                     edit: TextEditBuilder::new().finish(),
                     cursor_position: None,
                 };
@@ -51,6 +53,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
     }
 
     LocalEdit {
+        label: "join lines".to_string(),
         edit: edit.finish(),
         cursor_position: None,
     }
@@ -76,6 +79,7 @@ pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
     let mut edit = TextEditBuilder::new();
     edit.insert(offset, inserted);
     Some(LocalEdit {
+        label: "on enter".to_string(),
         edit: edit.finish(),
         cursor_position: Some(cursor_position),
     })
@@ -126,6 +130,7 @@ pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit>
     let mut edit = TextEditBuilder::new();
     edit.insert(offset, ";".to_string());
     Some(LocalEdit {
+        label: "add semicolon".to_string(),
         edit: edit.finish(),
         cursor_position: None,
     })
@@ -240,7 +245,7 @@ fn single_expr(block: ast::Block) -> Option<ast::Expr> {
 
 fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Option<()> {
     let use_tree_list = ast::UseTreeList::cast(node.parent()?)?;
-    let tree = single_use_tree(use_tree_list)?;
+    let (tree,) = use_tree_list.use_trees().collect_tuple()?;
     edit.replace(
         use_tree_list.syntax().range(),
         tree.syntax().text().to_string(),
@@ -248,26 +253,6 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Opti
     Some(())
 }
 
-fn single_use_tree(tree_list: ast::UseTreeList) -> Option<ast::UseTree> {
-    let mut res = None;
-    for child in tree_list.syntax().children() {
-        if let Some(tree) = ast::UseTree::cast(child) {
-            if tree.syntax().text().contains('\n') {
-                return None;
-            }
-            if mem::replace(&mut res, Some(tree)).is_some() {
-                return None;
-            }
-        } else {
-            match child.kind() {
-                WHITESPACE | L_CURLY | R_CURLY | COMMA => (),
-                _ => return None,
-            }
-        }
-    }
-    res
-}
-
 fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
     match left.kind() {
         L_PAREN | L_BRACK => return "",