allow rustfmt to reorder imports

This wasn't a right decision in the first place, the feature flag was
broken in the last rustfmt release, and syntax highlighting of imports
is more important anyway

22 files changed, 69 insertions, 78 deletions

diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index d31d00343..fad8da132 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -2,7 +2,7 @@ pub mod visit;
 
 use itertools::Itertools;
 
-use crate::{SyntaxNode, TextRange, TextUnit, AstNode, Direction, SyntaxToken, SyntaxElement};
+use crate::{AstNode, Direction, SyntaxElement, SyntaxNode, SyntaxToken, TextRange, TextUnit};
 
 pub use rowan::TokenAtOffset;
 
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 319110b6a..3dcf39f7e 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -9,16 +9,16 @@ mod expr_extensions;
 use std::marker::PhantomData;
 
 use crate::{
-    syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, SyntaxToken},
+    syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken, TreeArc},
     SmolStr,
 };
 
 pub use self::{
+    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp},
+    extensions::{FieldKind, PathSegmentKind, SelfParamKind, StructKind},
     generated::*,
-    traits::*,
     tokens::*,
-    extensions::{PathSegmentKind, StructKind,FieldKind, SelfParamKind},
-    expr_extensions::{ElseBranch, PrefixOp, BinOp, LiteralKind,ArrayExprKind},
+    traits::*,
 };
 
 /// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index d88671d45..87dbb0ea5 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -1,10 +1,10 @@
 //! Various extension methods to ast Expr Nodes, which are hard to code-generate.
 
 use crate::{
-    SyntaxToken, SyntaxElement, SmolStr,
-    ast::{self, AstNode, AstChildren, children, child_opt},
+    ast::{self, child_opt, children, AstChildren, AstNode},
+    SmolStr, SyntaxElement,
     SyntaxKind::*,
-    T
+    SyntaxToken, T,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 930b2d9fa..72a30232d 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -4,10 +4,10 @@
 use itertools::Itertools;
 
 use crate::{
-    SmolStr, SyntaxToken,
-    ast::{self, AstNode, children, child_opt},
+    ast::{self, child_opt, children, AstNode},
+    SmolStr, SyntaxElement,
     SyntaxKind::*,
-    SyntaxElement, T,
+    SyntaxToken, T,
 };
 use ra_parser::SyntaxKind;
 
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index 08882ea69..be63b3c9e 100644
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -1,9 +1,9 @@
 //! There are many AstNodes, but only a few tokens, so we hand-write them here.
 
 use crate::{
-    SyntaxToken,
-    SyntaxKind::{COMMENT, WHITESPACE},
     ast::AstToken,
+    SyntaxKind::{COMMENT, WHITESPACE},
+    SyntaxToken,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -61,7 +61,7 @@ pub enum CommentPlacement {
 }
 
 const COMMENT_PREFIX_TO_KIND: &[(&str, CommentKind)] = {
-    use {CommentShape::*, CommentPlacement::*};
+    use {CommentPlacement::*, CommentShape::*};
     &[
         ("///", CommentKind { shape: Line, doc: Some(Outer) }),
         ("//!", CommentKind { shape: Line, doc: Some(Inner) }),
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
index 433485400..29cb53e35 100644
--- a/crates/ra_syntax/src/ast/traits.rs
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -5,8 +5,8 @@
 use itertools::Itertools;
 
 use crate::{
-    syntax_node::{SyntaxNodeChildren, SyntaxElementChildren},
-    ast::{self, child_opt, children, AstNode, AstToken, AstChildren},
+    ast::{self, child_opt, children, AstChildren, AstNode, AstToken},
+    syntax_node::{SyntaxElementChildren, SyntaxNodeChildren},
 };
 
 pub trait TypeAscriptionOwner: AstNode {
diff --git a/crates/ra_syntax/src/fuzz.rs b/crates/ra_syntax/src/fuzz.rs
index 6a9905bd1..6d114aad4 100644
--- a/crates/ra_syntax/src/fuzz.rs
+++ b/crates/ra_syntax/src/fuzz.rs
@@ -1,4 +1,4 @@
-use crate::{SourceFile, validation, TextUnit, TextRange, AstNode};
+use crate::{validation, AstNode, SourceFile, TextRange, TextUnit};
 use ra_text_edit::AtomTextEdit;
 use std::str::{self, FromStr};
 
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index e46ad12db..9790a984d 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -31,23 +31,26 @@ pub mod ast;
 #[doc(hidden)]
 pub mod fuzz;
 
-use std::{sync::Arc, fmt::Write};
+use std::{fmt::Write, sync::Arc};
 
 use ra_text_edit::AtomTextEdit;
 
 use crate::syntax_node::GreenNode;
 
-pub use rowan::{SmolStr, TextRange, TextUnit};
-pub use ra_parser::SyntaxKind;
-pub use ra_parser::T;
 pub use crate::{
     ast::AstNode,
-    syntax_error::{SyntaxError, SyntaxErrorKind, Location},
+    parsing::{classify_literal, tokenize, Token},
+    ptr::{AstPtr, SyntaxNodePtr},
+    syntax_error::{Location, SyntaxError, SyntaxErrorKind},
+    syntax_node::{
+        Direction, InsertPosition, SyntaxElement, SyntaxNode, SyntaxToken, SyntaxTreeBuilder,
+        TreeArc, WalkEvent,
+    },
     syntax_text::SyntaxText,
-    syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc, SyntaxTreeBuilder, SyntaxElement, SyntaxToken, InsertPosition},
-    ptr::{SyntaxNodePtr, AstPtr},
-    parsing::{tokenize, classify_literal, Token},
 };
+pub use ra_parser::SyntaxKind;
+pub use ra_parser::T;
+pub use rowan::{SmolStr, TextRange, TextUnit};
 
 /// `Parse` is the result of the parsing: a syntax tree and a collection of
 /// errors.
diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs
index 4c1fa6c4f..0387f0378 100644
--- a/crates/ra_syntax/src/parsing.rs
+++ b/crates/ra_syntax/src/parsing.rs
@@ -6,12 +6,9 @@ mod text_token_source;
 mod text_tree_sink;
 mod reparsing;
 
-use crate::{
-    SyntaxError,
-    syntax_node::GreenNode,
-};
+use crate::{syntax_node::GreenNode, SyntaxError};
 
-pub use self::lexer::{tokenize, classify_literal, Token};
+pub use self::lexer::{classify_literal, tokenize, Token};
 
 pub(crate) use self::reparsing::incremental_reparse;
 
diff --git a/crates/ra_syntax/src/parsing/lexer.rs b/crates/ra_syntax/src/parsing/lexer.rs
index 6eb96f03d..60cf37047 100644
--- a/crates/ra_syntax/src/parsing/lexer.rs
+++ b/crates/ra_syntax/src/parsing/lexer.rs
@@ -6,8 +6,7 @@ mod strings;
 
 use crate::{
     SyntaxKind::{self, *},
-    TextUnit,
-    T,
+    TextUnit, T,
 };
 
 use self::{
diff --git a/crates/ra_syntax/src/parsing/lexer/numbers.rs b/crates/ra_syntax/src/parsing/lexer/numbers.rs
index 874fb8b32..e53ae231b 100644
--- a/crates/ra_syntax/src/parsing/lexer/numbers.rs
+++ b/crates/ra_syntax/src/parsing/lexer/numbers.rs
@@ -1,7 +1,4 @@
-use crate::parsing::lexer::{
-    ptr::Ptr,
-    classes::*,
-};
+use crate::parsing::lexer::{classes::*, ptr::Ptr};
 
 use crate::SyntaxKind::{self, *};
 
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index cf27a3393..eeca94020 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -6,19 +6,20 @@
 //!   - otherwise, we search for the nearest `{}` block which contains the edit
 //!     and try to parse only this block.
 
-use ra_text_edit::AtomTextEdit;
 use ra_parser::Reparser;
+use ra_text_edit::AtomTextEdit;
 
 use crate::{
-    SyntaxKind::*, TextRange, TextUnit, SyntaxError,
     algo,
-    syntax_node::{GreenNode, SyntaxNode, GreenToken, SyntaxElement},
     parsing::{
+        lexer::{tokenize, Token},
         text_token_source::TextTokenSource,
         text_tree_sink::TextTreeSink,
-        lexer::{tokenize, Token},
     },
-    T,
+    syntax_node::{GreenNode, GreenToken, SyntaxElement, SyntaxNode},
+    SyntaxError,
+    SyntaxKind::*,
+    TextRange, TextUnit, T,
 };
 
 pub(crate) fn incremental_reparse(
@@ -168,10 +169,10 @@ fn merge_errors(
 mod tests {
     use std::sync::Arc;
 
-    use test_utils::{extract_range, assert_eq_text};
+    use test_utils::{assert_eq_text, extract_range};
 
-    use crate::{SourceFile, AstNode, Parse};
     use super::*;
+    use crate::{AstNode, Parse, SourceFile};
 
     fn do_check(before: &str, replace_with: &str, reparsed_len: u32) {
         let (range, before) = extract_range(before);
diff --git a/crates/ra_syntax/src/parsing/text_token_source.rs b/crates/ra_syntax/src/parsing/text_token_source.rs
index 71d2947f7..f592b499f 100644
--- a/crates/ra_syntax/src/parsing/text_token_source.rs
+++ b/crates/ra_syntax/src/parsing/text_token_source.rs
@@ -1,10 +1,7 @@
-use ra_parser::TokenSource;
 use ra_parser::Token as PToken;
+use ra_parser::TokenSource;
 
-use crate::{
-    SyntaxKind::EOF, TextRange, TextUnit,
-    parsing::lexer::Token,
-};
+use crate::{parsing::lexer::Token, SyntaxKind::EOF, TextRange, TextUnit};
 
 pub(crate) struct TextTokenSource<'t> {
     text: &'t str,
diff --git a/crates/ra_syntax/src/parsing/text_tree_sink.rs b/crates/ra_syntax/src/parsing/text_tree_sink.rs
index 71fc515f2..bf1b35c95 100644
--- a/crates/ra_syntax/src/parsing/text_tree_sink.rs
+++ b/crates/ra_syntax/src/parsing/text_tree_sink.rs
@@ -1,12 +1,13 @@
 use std::mem;
 
-use ra_parser::{TreeSink, ParseError};
+use ra_parser::{ParseError, TreeSink};
 
 use crate::{
-    SmolStr, SyntaxError, TextUnit, TextRange, SyntaxTreeBuilder,
-    SyntaxKind::{self, *},
     parsing::Token,
     syntax_node::GreenNode,
+    SmolStr, SyntaxError,
+    SyntaxKind::{self, *},
+    SyntaxTreeBuilder, TextRange, TextUnit,
 };
 
 /// Bridges the parser with our specific syntax tree representation.
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index 10cddb852..0550dca1a 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -1,10 +1,5 @@
-use std::{
-    marker::PhantomData,
-    iter::successors,
-};
-use crate::{
-    AstNode, SyntaxKind, SyntaxNode, TextRange,
-};
+use crate::{AstNode, SyntaxKind, SyntaxNode, TextRange};
+use std::{iter::successors, marker::PhantomData};
 
 /// A pointer to a syntax node inside a file. It can be used to remember a
 /// specific node across reparses of the same file.
diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs
index d29c0cf6c..5aefec768 100644
--- a/crates/ra_syntax/src/syntax_error.rs
+++ b/crates/ra_syntax/src/syntax_error.rs
@@ -2,10 +2,7 @@ use std::fmt;
 
 use ra_parser::ParseError;
 
-use crate::{
-    TextRange, TextUnit,
-    validation::EscapeError,
-};
+use crate::{validation::EscapeError, TextRange, TextUnit};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxError {
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index 4105b5220..80c8639c8 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -7,18 +7,18 @@
 //! modules just wraps its API.
 
 use std::{
-    ops::RangeInclusive,
-    fmt::{self, Write},
     borrow::Borrow,
+    fmt::{self, Write},
     iter::successors,
+    ops::RangeInclusive,
 };
 
 use ra_parser::ParseError;
-use rowan::{TransparentNewType, GreenNodeBuilder};
+use rowan::{GreenNodeBuilder, TransparentNewType};
 
 use crate::{
-    SmolStr, SyntaxKind, TextUnit, TextRange, SyntaxText, SourceFile, AstNode, SyntaxNodePtr,
     syntax_error::{SyntaxError, SyntaxErrorKind},
+    AstNode, SmolStr, SourceFile, SyntaxKind, SyntaxNodePtr, SyntaxText, TextRange, TextUnit,
 };
 
 pub use rowan::WalkEvent;
diff --git a/crates/ra_syntax/src/syntax_text.rs b/crates/ra_syntax/src/syntax_text.rs
index c9038cd5c..e648dc082 100644
--- a/crates/ra_syntax/src/syntax_text.rs
+++ b/crates/ra_syntax/src/syntax_text.rs
@@ -1,6 +1,9 @@
-use std::{fmt, ops::{self, Bound}};
+use std::{
+    fmt,
+    ops::{self, Bound},
+};
 
-use crate::{SmolStr, SyntaxNode, TextRange, TextUnit, SyntaxElement};
+use crate::{SmolStr, SyntaxElement, SyntaxNode, TextRange, TextUnit};
 
 #[derive(Clone)]
 pub struct SyntaxText<'a> {
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index b53900a4b..87522ec18 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -4,11 +4,10 @@ mod block;
 mod field_expr;
 
 use crate::{
-    SourceFile, SyntaxError, AstNode, SyntaxNode, TextUnit,
-    SyntaxKind::{BYTE, BYTE_STRING, STRING, CHAR},
-    ast,
     algo::visit::{visitor_ctx, VisitorCtx},
-    T,
+    ast, AstNode, SourceFile, SyntaxError,
+    SyntaxKind::{BYTE, BYTE_STRING, CHAR, STRING},
+    SyntaxNode, TextUnit, T,
 };
 
 pub(crate) use unescape::EscapeError;
diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs
index f2cf3cbbd..46650d9b0 100644
--- a/crates/ra_syntax/src/validation/block.rs
+++ b/crates/ra_syntax/src/validation/block.rs
@@ -1,7 +1,8 @@
-use crate::{SyntaxKind::*,
-    ast::{self, AttrsOwner, AstNode},
+use crate::{
+    ast::{self, AstNode, AttrsOwner},
     SyntaxError,
     SyntaxErrorKind::*,
+    SyntaxKind::*,
 };
 
 pub(crate) fn validate_block_node(node: &ast::Block, errors: &mut Vec<SyntaxError>) {
diff --git a/crates/ra_syntax/src/validation/field_expr.rs b/crates/ra_syntax/src/validation/field_expr.rs
index 2b405062e..d3020edf7 100644
--- a/crates/ra_syntax/src/validation/field_expr.rs
+++ b/crates/ra_syntax/src/validation/field_expr.rs
@@ -1,6 +1,7 @@
-use crate::{ast::{self, FieldKind},

-            SyntaxError,

-            SyntaxErrorKind::*,

+use crate::{

+    ast::{self, FieldKind},

+    SyntaxError,

+    SyntaxErrorKind::*,

 };

 

 pub(crate) fn validate_field_expr_node(node: &ast::FieldExpr, errors: &mut Vec<SyntaxError>) {

diff --git a/crates/ra_syntax/src/validation/unescape.rs b/crates/ra_syntax/src/validation/unescape.rs
index 91dbcfae8..4c3a7effc 100644
--- a/crates/ra_syntax/src/validation/unescape.rs
+++ b/crates/ra_syntax/src/validation/unescape.rs
@@ -7,8 +7,8 @@
 //!
 //! Hopefully, we'll share this code in a proper way some day
 
-use std::str::Chars;
 use std::ops::Range;
+use std::str::Chars;
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum EscapeError {