cargo fmt

Author: BenjaminBrienen

crates/base-db/src/change.rs

@@ -90,9 +90,5 @@ impl FileChange {
 }
 
 fn durability(source_root: &SourceRoot) -> Durability {
-    if source_root.is_library {
-        Durability::HIGH
-    } else {
-        Durability::LOW
-    }
+    if source_root.is_library { Durability::HIGH } else { Durability::LOW }
 }

crates/base-db/src/input.rs

@@ -14,7 +14,7 @@ use la_arena::{Arena, Idx, RawIdx};
 use rustc_hash::{FxHashMap, FxHashSet};
 use span::{Edition, EditionedFileId};
 use triomphe::Arc;
-use vfs::{file_set::FileSet, AbsPathBuf, AnchoredPath, FileId, VfsPath};
+use vfs::{AbsPathBuf, AnchoredPath, FileId, VfsPath, file_set::FileSet};
 
 pub type ProcMacroPaths = FxHashMap<CrateId, Result<(String, AbsPathBuf), String>>;
 
@@ -105,11 +105,7 @@ impl CrateName {
     /// Dashes are not allowed in the crate names,
     /// hence the input string is returned as `Err` for those cases.
     pub fn new(name: &str) -> Result<CrateName, &str> {
-        if name.contains('-') {
-            Err(name)
-        } else {
-            Ok(Self(Symbol::intern(name)))
-        }
+        if name.contains('-') { Err(name) } else { Ok(Self(Symbol::intern(name))) }
     }
 
     /// Creates a crate name, unconditionally replacing the dashes with underscores.
@@ -731,15 +727,21 @@ mod tests {
             false,
             None,
         );
-        assert!(graph
-            .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
-            .is_ok());
-        assert!(graph
-            .add_dep(crate2, Dependency::new(CrateName::new("crate3").unwrap(), crate3,))
-            .is_ok());
-        assert!(graph
-            .add_dep(crate3, Dependency::new(CrateName::new("crate1").unwrap(), crate1,))
-            .is_err());
+        assert!(
+            graph
+                .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
+                .is_ok()
+        );
+        assert!(
+            graph
+                .add_dep(crate2, Dependency::new(CrateName::new("crate3").unwrap(), crate3,))
+                .is_ok()
+        );
+        assert!(
+            graph
+                .add_dep(crate3, Dependency::new(CrateName::new("crate1").unwrap(), crate1,))
+                .is_err()
+        );
     }
 
     #[test]
@@ -769,12 +771,16 @@ mod tests {
             false,
             None,
         );
-        assert!(graph
-            .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
-            .is_ok());
-        assert!(graph
-            .add_dep(crate2, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
-            .is_err());
+        assert!(
+            graph
+                .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
+                .is_ok()
+        );
+        assert!(
+            graph
+                .add_dep(crate2, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
+                .is_err()
+        );
     }
 
     #[test]
@@ -816,12 +822,16 @@ mod tests {
             false,
             None,
         );
-        assert!(graph
-            .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
-            .is_ok());
-        assert!(graph
-            .add_dep(crate2, Dependency::new(CrateName::new("crate3").unwrap(), crate3,))
-            .is_ok());
+        assert!(
+            graph
+                .add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2,))
+                .is_ok()
+        );
+        assert!(
+            graph
+                .add_dep(crate2, Dependency::new(CrateName::new("crate3").unwrap(), crate3,))
+                .is_ok()
+        );
     }
 
     #[test]
@@ -851,12 +861,14 @@ mod tests {
             false,
             None,
         );
-        assert!(graph
-            .add_dep(
-                crate1,
-                Dependency::new(CrateName::normalize_dashes("crate-name-with-dashes"), crate2,)
-            )
-            .is_ok());
+        assert!(
+            graph
+                .add_dep(
+                    crate1,
+                    Dependency::new(CrateName::normalize_dashes("crate-name-with-dashes"), crate2,)
+                )
+                .is_ok()
+        );
         assert_eq!(
             graph[crate1].dependencies,
             vec![Dependency::new(CrateName::new("crate_name_with_dashes").unwrap(), crate2,)]

crates/base-db/src/lib.rs

@@ -8,7 +8,7 @@ use std::panic;
 use ra_salsa::Durability;
 use rustc_hash::FxHashMap;
 use span::EditionedFileId;
-use syntax::{ast, Parse, SourceFile, SyntaxError};
+use syntax::{Parse, SourceFile, SyntaxError, ast};
 use triomphe::Arc;
 use vfs::FileId;
 
@@ -21,7 +21,7 @@ pub use crate::{
     },
 };
 pub use ra_salsa::{self, Cancelled};
-pub use vfs::{file_set::FileSet, AnchoredPath, AnchoredPathBuf, VfsPath};
+pub use vfs::{AnchoredPath, AnchoredPathBuf, VfsPath, file_set::FileSet};
 
 pub use semver::{BuildMetadata, Prerelease, Version, VersionReq};
 

crates/cfg/src/lib.rs

@@ -9,7 +9,7 @@ use std::fmt;
 
 use rustc_hash::FxHashSet;
 
-use intern::{sym, Symbol};
+use intern::{Symbol, sym};
 
 pub use cfg_expr::{CfgAtom, CfgExpr};
 pub use dnf::DnfExpr;

crates/cfg/src/tests.rs

@@ -1,10 +1,11 @@
 use arbitrary::{Arbitrary, Unstructured};
-use expect_test::{expect, Expect};
+use expect_test::{Expect, expect};
 use intern::Symbol;
-use syntax::{ast, AstNode, Edition};
+use syntax::{AstNode, Edition, ast};
 use syntax_bridge::{
-    dummy_test_span_utils::{DummyTestSpanMap, DUMMY},
-    syntax_node_to_token_tree, DocCommentDesugarMode,
+    DocCommentDesugarMode,
+    dummy_test_span_utils::{DUMMY, DummyTestSpanMap},
+    syntax_node_to_token_tree,
 };
 
 use crate::{CfgAtom, CfgExpr, CfgOptions, DnfExpr};

crates/hir-def/src/attr.rs

@@ -6,27 +6,27 @@ use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
 use hir_expand::{
-    attrs::{collect_attrs, Attr, AttrId, RawAttrs},
     HirFileId, InFile,
+    attrs::{Attr, AttrId, RawAttrs, collect_attrs},
 };
-use intern::{sym, Symbol};
+use intern::{Symbol, sym};
 use la_arena::{ArenaMap, Idx, RawIdx};
 use mbe::DelimiterKind;
 use syntax::{
-    ast::{self, HasAttrs},
     AstPtr,
+    ast::{self, HasAttrs},
 };
 use triomphe::Arc;
 use tt::iter::{TtElement, TtIter};
 
 use crate::{
+    AdtId, AttrDefId, GenericParamId, HasModule, ItemTreeLoc, LocalFieldId, Lookup, MacroId,
+    VariantId,
     db::DefDatabase,
     item_tree::{AttrOwner, FieldParent, ItemTreeNode},
     lang_item::LangItem,
     nameres::{ModuleOrigin, ModuleSource},
     src::{HasChildSource, HasSource},
-    AdtId, AttrDefId, GenericParamId, HasModule, ItemTreeLoc, LocalFieldId, Lookup, MacroId,
-    VariantId,
 };
 
 /// Desugared attributes of an item post `cfg_attr` expansion.
@@ -649,8 +649,8 @@ mod tests {
 
     use hir_expand::span_map::{RealSpanMap, SpanMap};
     use span::FileId;
-    use syntax::{ast, AstNode, TextRange};
-    use syntax_bridge::{syntax_node_to_token_tree, DocCommentDesugarMode};
+    use syntax::{AstNode, TextRange, ast};
+    use syntax_bridge::{DocCommentDesugarMode, syntax_node_to_token_tree};
 
     use crate::attr::{DocAtom, DocExpr};
 

crates/hir-def/src/builtin_type.rs

@@ -6,7 +6,7 @@
 use std::fmt;
 
 use hir_expand::name::{AsName, Name};
-use intern::{sym, Symbol};
+use intern::{Symbol, sym};
 /// Different signed int types.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum BuiltinInt {

crates/hir-def/src/data.rs

@@ -4,32 +4,32 @@ pub mod adt;
 
 use base_db::CrateId;
 use hir_expand::{
-    name::Name, AstId, ExpandResult, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefKind,
+    AstId, ExpandResult, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefKind, name::Name,
 };
-use intern::{sym, Symbol};
+use intern::{Symbol, sym};
 use la_arena::{Idx, RawIdx};
 use smallvec::SmallVec;
-use syntax::{ast, Parse};
+use syntax::{Parse, ast};
 use triomphe::Arc;
 use tt::iter::TtElement;
 
 use crate::{
+    AssocItemId, AstIdWithPath, ConstId, ConstLoc, ExternCrateId, FunctionId, FunctionLoc,
+    HasModule, ImplId, Intern, ItemContainerId, ItemLoc, Lookup, Macro2Id, MacroRulesId, ModuleId,
+    ProcMacroId, StaticId, TraitAliasId, TraitId, TypeAliasId, TypeAliasLoc,
     db::DefDatabase,
     expander::{Expander, Mark},
     item_tree::{self, AssocItem, FnFlags, ItemTree, ItemTreeId, MacroCall, ModItem, TreeId},
     macro_call_as_call_id,
     nameres::{
+        DefMap, MacroSubNs,
         attr_resolution::ResolvedAttr,
         diagnostics::{DefDiagnostic, DefDiagnostics},
-        proc_macro::{parse_macro_name_and_helper_attrs, ProcMacroKind},
-        DefMap, MacroSubNs,
+        proc_macro::{ProcMacroKind, parse_macro_name_and_helper_attrs},
     },
     path::ImportAlias,
     type_ref::{TraitRef, TypeBound, TypeRefId, TypesMap},
     visibility::RawVisibility,
-    AssocItemId, AstIdWithPath, ConstId, ConstLoc, ExternCrateId, FunctionId, FunctionLoc,
-    HasModule, ImplId, Intern, ItemContainerId, ItemLoc, Lookup, Macro2Id, MacroRulesId, ModuleId,
-    ProcMacroId, StaticId, TraitAliasId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -543,11 +543,7 @@ impl ExternCrateDeclData {
             Some(krate)
         } else {
             db.crate_graph()[krate].dependencies.iter().find_map(|dep| {
-                if dep.name.symbol() == name.symbol() {
-                    Some(dep.crate_id)
-                } else {
-                    None
-                }
+                if dep.name.symbol() == name.symbol() { Some(dep.crate_id) } else { None }
             })
         };
 

crates/hir-def/src/data/adt.rs

@@ -14,6 +14,7 @@ use triomphe::Arc;
 use tt::iter::TtElement;
 
 use crate::{
+    EnumId, EnumVariantId, LocalFieldId, LocalModuleId, Lookup, StructId, UnionId, VariantId,
     builtin_type::{BuiltinInt, BuiltinUint},
     db::DefDatabase,
     hir::Expr,
@@ -25,7 +26,6 @@ use crate::{
     tt::{Delimiter, DelimiterKind, Leaf, TopSubtree},
     type_ref::{TypeRefId, TypesMap},
     visibility::RawVisibility,
-    EnumId, EnumVariantId, LocalFieldId, LocalModuleId, Lookup, StructId, UnionId, VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!

crates/hir-def/src/db.rs

@@ -1,36 +1,36 @@
 //! Defines database & queries for name resolution.
-use base_db::{ra_salsa, CrateId, SourceDatabase, Upcast};
+use base_db::{CrateId, SourceDatabase, Upcast, ra_salsa};
 use either::Either;
-use hir_expand::{db::ExpandDatabase, HirFileId, MacroDefId};
+use hir_expand::{HirFileId, MacroDefId, db::ExpandDatabase};
 use intern::sym;
 use la_arena::ArenaMap;
 use span::{EditionedFileId, MacroCallId};
-use syntax::{ast, AstPtr};
+use syntax::{AstPtr, ast};
 use triomphe::Arc;
 
 use crate::{
+    AttrDefId, BlockId, BlockLoc, ConstBlockId, ConstBlockLoc, ConstId, ConstLoc, DefWithBodyId,
+    EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
+    ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, InTypeConstId,
+    InTypeConstLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroId, MacroRulesId, MacroRulesLoc,
+    MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc,
+    TraitAliasId, TraitAliasLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+    UseId, UseLoc, VariantId,
     attr::{Attrs, AttrsWithOwner},
     data::{
-        adt::{EnumData, EnumVariantData, StructData, VariantData},
         ConstData, ExternCrateDeclData, FunctionData, ImplData, Macro2Data, MacroRulesData,
         ProcMacroData, StaticData, TraitAliasData, TraitData, TypeAliasData,
+        adt::{EnumData, EnumVariantData, StructData, VariantData},
     },
-    expr_store::{scope::ExprScopes, Body, BodySourceMap},
+    expr_store::{Body, BodySourceMap, scope::ExprScopes},
     generics::GenericParams,
     import_map::ImportMap,
     item_tree::{AttrOwner, ItemTree, ItemTreeSourceMaps},
     lang_item::{self, LangItem, LangItemTarget, LangItems},
-    nameres::{diagnostics::DefDiagnostics, DefMap},
+    nameres::{DefMap, diagnostics::DefDiagnostics},
     tt,
     type_ref::TypesSourceMap,
     visibility::{self, Visibility},
-    AttrDefId, BlockId, BlockLoc, ConstBlockId, ConstBlockLoc, ConstId, ConstLoc, DefWithBodyId,
-    EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
-    ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, InTypeConstId,
-    InTypeConstLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroId, MacroRulesId, MacroRulesLoc,
-    MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc,
-    TraitAliasId, TraitAliasLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
-    UseId, UseLoc, VariantId,
 };
 
 #[ra_salsa::query_group(InternDatabaseStorage)]
@@ -304,7 +304,7 @@ fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: CrateId) -> bool {
         for output in segments.skip(1) {
             match output.flat_tokens() {
                 [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.sym == sym::no_std => {
-                    return true
+                    return true;
                 }
                 _ => {}
             }

crates/hir-def/src/dyn_map.rs

@@ -27,15 +27,15 @@
 pub mod keys {
     use std::marker::PhantomData;
 
-    use hir_expand::{attrs::AttrId, MacroCallId};
+    use hir_expand::{MacroCallId, attrs::AttrId};
     use rustc_hash::FxHashMap;
-    use syntax::{ast, AstNode, AstPtr};
+    use syntax::{AstNode, AstPtr, ast};
 
     use crate::{
-        dyn_map::{DynMap, Policy},
         BlockId, ConstId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId,
         ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId,
         TraitAliasId, TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId,
+        dyn_map::{DynMap, Policy},
     };
 
     pub type Key<K, V> = crate::dyn_map::Key<AstPtr<K>, V, AstPtrPolicy<K, V>>;