Reformat use declarations.

The previous commit updated `rustfmt.toml` appropriately. This commit is
the outcome of running `x fmt --all` with the new formatting options.

compiler/rustc_abi/src/layout.rs

@@ -1,9 +1,7 @@
 use std::borrow::{Borrow, Cow};
-use std::cmp;
 use std::fmt::{self, Write};
-use std::iter;
+use std::ops::{Bound, Deref};
-use std::ops::Bound;
+use std::{cmp, iter};
-use std::ops::Deref;
 
 use rustc_index::Idx;
 use tracing::debug;
@@ -982,7 +980,8 @@ fn univariant<
         if repr.can_randomize_type_layout() && cfg!(feature = "randomize") {
             #[cfg(feature = "randomize")]
             {
-                use rand::{seq::SliceRandom, SeedableRng};
+                use rand::seq::SliceRandom;
+                use rand::SeedableRng;
                 // `ReprOptions.field_shuffle_seed` is a deterministic seed we can use to randomize field
                 // ordering.
                 let mut rng =

compiler/rustc_abi/src/lib.rs

@@ -6,21 +6,20 @@
 // tidy-alphabetical-end
 
 use std::fmt;
+#[cfg(feature = "nightly")]
+use std::iter::Step;
 use std::num::{NonZeroUsize, ParseIntError};
 use std::ops::{Add, AddAssign, Mul, RangeInclusive, Sub};
 use std::str::FromStr;
 
 use bitflags::bitflags;
-use rustc_index::{Idx, IndexSlice, IndexVec};
-
 #[cfg(feature = "nightly")]
 use rustc_data_structures::stable_hasher::StableOrd;
+use rustc_index::{Idx, IndexSlice, IndexVec};
 #[cfg(feature = "nightly")]
 use rustc_macros::HashStable_Generic;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_Generic, Encodable_Generic};
-#[cfg(feature = "nightly")]
-use std::iter::Step;
 
 mod layout;
 #[cfg(test)]

compiler/rustc_arena/src/lib.rs

@@ -27,15 +27,14 @@
 #![feature(strict_provenance)]
 // tidy-alphabetical-end
 
-use smallvec::SmallVec;
-
 use std::alloc::Layout;
 use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::mem::{self, MaybeUninit};
 use std::ptr::{self, NonNull};
-use std::slice;
+use std::{cmp, intrinsics, slice};
-use std::{cmp, intrinsics};
+
+use smallvec::SmallVec;
 
 /// This calls the passed function while ensuring it won't be inlined into the caller.
 #[inline(never)]

compiler/rustc_arena/src/tests.rs

@@ -1,8 +1,10 @@
 extern crate test;
-use super::TypedArena;
 use std::cell::Cell;
+
 use test::Bencher;
 
+use super::TypedArena;
+
 #[allow(dead_code)]
 #[derive(Debug, Eq, PartialEq)]
 struct Point {

compiler/rustc_ast/src/ast.rs

@@ -18,15 +18,9 @@
 //! - [`Attribute`]: Metadata associated with item.
 //! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
 
-pub use crate::format::*;
+use std::borrow::Cow;
-pub use crate::util::parser::ExprPrecedence;
+use std::{cmp, fmt, mem};
-pub use rustc_span::AttrId;
-pub use GenericArgs::*;
-pub use UnsafeSource::*;
 
-use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter};
-use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
 pub use rustc_ast_ir::{Movability, Mutability};
 use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -35,12 +29,17 @@ use rustc_data_structures::sync::Lrc;
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
+pub use rustc_span::AttrId;
 use rustc_span::{ErrorGuaranteed, Span, DUMMY_SP};
-use std::borrow::Cow;
-use std::cmp;
-use std::fmt;
-use std::mem;
 use thin_vec::{thin_vec, ThinVec};
+pub use GenericArgs::*;
+pub use UnsafeSource::*;
+
+pub use crate::format::*;
+use crate::ptr::P;
+use crate::token::{self, CommentKind, Delimiter};
+use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
+pub use crate::util::parser::ExprPrecedence;
 
 /// A "Label" is an identifier of some point in sources,
 /// e.g. in the following code:
@@ -3491,8 +3490,9 @@ pub type ForeignItem = Item<ForeignItemKind>;
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 mod size_asserts {
-    use super::*;
     use rustc_data_structures::static_assert_size;
+
+    use super::*;
     // tidy-alphabetical-start
     static_assert_size!(AssocItem, 88);
     static_assert_size!(AssocItemKind, 16);

compiler/rustc_ast/src/ast_traits.rs

@@ -2,16 +2,17 @@
 //! typically those used in AST fragments during macro expansion.
 //! The traits are not implemented exhaustively, only when actually necessary.
 
+use std::fmt;
+use std::marker::PhantomData;
+
 use crate::ptr::P;
 use crate::token::Nonterminal;
 use crate::tokenstream::LazyAttrTokenStream;
-use crate::{Arm, Crate, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
+use crate::{
-use crate::{AssocItem, Expr, ForeignItem, Item, NodeId};
+    Arm, AssocItem, AttrItem, AttrKind, AttrVec, Attribute, Block, Crate, Expr, ExprField,
-use crate::{AttrItem, AttrKind, Block, Pat, Path, Ty, Visibility};
+    FieldDef, ForeignItem, GenericParam, Item, NodeId, Param, Pat, PatField, Path, Stmt, StmtKind,
-use crate::{AttrVec, Attribute, Stmt, StmtKind};
+    Ty, Variant, Visibility,
-
+};
-use std::fmt;
-use std::marker::PhantomData;
 
 /// A utility trait to reduce boilerplate.
 /// Standard `Deref(Mut)` cannot be reused due to coherence.

compiler/rustc_ast/src/attr/mod.rs

@@ -1,25 +1,25 @@
 //! Functions dealing with attributes and meta items.
 
-use crate::ast::{
+use std::iter;
-    AttrArgs, AttrArgsEq, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, Safety,
+use std::sync::atomic::{AtomicU32, Ordering};
-};
+
-use crate::ast::{DelimArgs, Expr, ExprKind, LitKind, MetaItemLit};
-use crate::ast::{MetaItem, MetaItemKind, NestedMetaItem, NormalAttr};
-use crate::ast::{Path, PathSegment, DUMMY_NODE_ID};
-use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter, Token};
-use crate::tokenstream::{DelimSpan, Spacing, TokenTree};
-use crate::tokenstream::{LazyAttrTokenStream, TokenStream};
-use crate::util::comments;
-use crate::util::literal::escape_string_symbol;
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 use smallvec::{smallvec, SmallVec};
-use std::iter;
-use std::sync::atomic::{AtomicU32, Ordering};
 use thin_vec::{thin_vec, ThinVec};
 
+use crate::ast::{
+    AttrArgs, AttrArgsEq, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, DelimArgs,
+    Expr, ExprKind, LitKind, MetaItem, MetaItemKind, MetaItemLit, NestedMetaItem, NormalAttr, Path,
+    PathSegment, Safety, DUMMY_NODE_ID,
+};
+use crate::ptr::P;
+use crate::token::{self, CommentKind, Delimiter, Token};
+use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, Spacing, TokenStream, TokenTree};
+use crate::util::comments;
+use crate::util::literal::escape_string_symbol;
+
 pub struct MarkedAttrs(GrowableBitSet<AttrId>);
 
 impl MarkedAttrs {

compiler/rustc_ast/src/entry.rs

@@ -1,7 +1,8 @@
-use crate::{attr, Attribute};
 use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
+use crate::{attr, Attribute};
+
 #[derive(Debug)]
 pub enum EntryPointType {
     /// This function is not an entrypoint.

compiler/rustc_ast/src/expand/mod.rs

@@ -1,7 +1,8 @@
 //! Definitions shared by macros / syntax extensions and e.g. `rustc_middle`.
 
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::{def_id::DefId, symbol::Ident};
+use rustc_span::def_id::DefId;
+use rustc_span::symbol::Ident;
 
 use crate::MetaItem;
 

compiler/rustc_ast/src/format.rs

@@ -1,10 +1,11 @@
-use crate::ptr::P;
-use crate::Expr;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_macros::{Decodable, Encodable};
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
 
+use crate::ptr::P;
+use crate::Expr;
+
 // Definitions:
 //
 // format_args!("hello {abc:.xyz$}!!", abc="world");

compiler/rustc_ast/src/lib.rs

@@ -43,11 +43,11 @@ pub mod token;
 pub mod tokenstream;
 pub mod visit;
 
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+
 pub use self::ast::*;
 pub use self::ast_traits::{AstDeref, AstNodeWrapper, HasAttrs, HasNodeId, HasTokens};
 
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-
 /// Requirements for a `StableHashingContext` to be used in this crate.
 /// This is a hack to allow using the `HashStable_Generic` derive macro
 /// instead of implementing everything in `rustc_middle`.

compiler/rustc_ast/src/mut_visit.rs

@@ -7,11 +7,8 @@
 //! a `MutVisitor` renaming item names in a module will miss all of those
 //! that are created by the expansion of a macro.
 
-use crate::ast::*;
+use std::ops::DerefMut;
-use crate::ptr::P;
+use std::panic;
-use crate::token::{self, Token};
-use crate::tokenstream::*;
-use crate::visit::{AssocCtxt, BoundKind};
 
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -20,10 +17,14 @@ use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
 use smallvec::{smallvec, Array, SmallVec};
-use std::ops::DerefMut;
-use std::panic;
 use thin_vec::ThinVec;
 
+use crate::ast::*;
+use crate::ptr::P;
+use crate::token::{self, Token};
+use crate::tokenstream::*;
+use crate::visit::{AssocCtxt, BoundKind};
+
 pub trait ExpectOne<A: Array> {
     fn expect_one(self, err: &'static str) -> A::Item;
 }

compiler/rustc_ast/src/node_id.rs

@@ -1,6 +1,7 @@
-use rustc_span::LocalExpnId;
 use std::fmt;
 
+use rustc_span::LocalExpnId;
+
 rustc_index::newtype_index! {
     /// Identifies an AST node.
     ///

compiler/rustc_ast/src/ptr.rs

@@ -21,9 +21,8 @@ use std::fmt::{self, Debug, Display};
 use std::ops::{Deref, DerefMut};
 use std::{slice, vec};
 
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
-
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 /// An owned smart pointer.
 ///
 /// See the [module level documentation][crate::ptr] for details.

compiler/rustc_ast/src/token.rs

@@ -1,3 +1,15 @@
+use std::borrow::Cow;
+use std::fmt;
+
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::sync::Lrc;
+use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_span::edition::Edition;
+use rustc_span::symbol::{kw, sym};
+#[allow(clippy::useless_attribute)] // FIXME: following use of `hidden_glob_reexports` incorrectly triggers `useless_attribute` lint.
+#[allow(hidden_glob_reexports)]
+use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::{ErrorGuaranteed, Span, DUMMY_SP};
 pub use BinOpToken::*;
 pub use LitKind::*;
 pub use Nonterminal::*;
@@ -9,17 +21,6 @@ use crate::ast;
 use crate::ptr::P;
 use crate::util::case::Case;
 
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::sync::Lrc;
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::symbol::{kw, sym};
-#[allow(clippy::useless_attribute)] // FIXME: following use of `hidden_glob_reexports` incorrectly triggers `useless_attribute` lint.
-#[allow(hidden_glob_reexports)]
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::{edition::Edition, ErrorGuaranteed, Span, DUMMY_SP};
-use std::borrow::Cow;
-use std::fmt;
-
 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum CommentKind {
     Line,
@@ -1062,8 +1063,9 @@ where
 // Some types are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 mod size_asserts {
-    use super::*;
     use rustc_data_structures::static_assert_size;
+
+    use super::*;
     // tidy-alphabetical-start
     static_assert_size!(Lit, 12);
     static_assert_size!(LitKind, 2);

compiler/rustc_ast/src/tokenstream.rs

@@ -13,10 +13,8 @@
 //! and a borrowed `TokenStream` is sufficient to build an owned `TokenStream` without taking
 //! ownership of the original.
 
-use crate::ast::{AttrStyle, StmtKind};
+use std::borrow::Cow;
-use crate::ast_traits::{HasAttrs, HasTokens};
+use std::{cmp, fmt, iter};
-use crate::token::{self, Delimiter, Nonterminal, Token, TokenKind};
-use crate::{AttrVec, Attribute};
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{self, Lrc};
@@ -24,8 +22,10 @@ use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_serialize::{Decodable, Encodable};
 use rustc_span::{sym, Span, SpanDecoder, SpanEncoder, Symbol, DUMMY_SP};
 
-use std::borrow::Cow;
+use crate::ast::{AttrStyle, StmtKind};
-use std::{cmp, fmt, iter};
+use crate::ast_traits::{HasAttrs, HasTokens};
+use crate::token::{self, Delimiter, Nonterminal, Token, TokenKind};
+use crate::{AttrVec, Attribute};
 
 /// Part of a `TokenStream`.
 #[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
@@ -767,8 +767,9 @@ impl DelimSpacing {
 // Some types are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 mod size_asserts {
-    use super::*;
     use rustc_data_structures::static_assert_size;
+
+    use super::*;
     // tidy-alphabetical-start
     static_assert_size!(AttrTokenStream, 8);
     static_assert_size!(AttrTokenTree, 32);

compiler/rustc_ast/src/util/comments.rs

@@ -1,6 +1,7 @@
-use crate::token::CommentKind;
 use rustc_span::{BytePos, Symbol};
 
+use crate::token::CommentKind;
+
 #[cfg(test)]
 mod tests;
 

compiler/rustc_ast/src/util/comments/tests.rs

@@ -1,6 +1,7 @@
-use super::*;
 use rustc_span::create_default_session_globals_then;
 
+use super::*;
+
 #[test]
 fn test_block_doc_comment_1() {
     create_default_session_globals_then(|| {

compiler/rustc_ast/src/util/literal.rs

@@ -1,15 +1,17 @@
 //! Code related to parsing literals.
 
-use crate::ast::{self, LitKind, MetaItemLit, StrStyle};
+use std::{ascii, fmt, str};
-use crate::token::{self, Token};
+
 use rustc_lexer::unescape::{
     byte_from_char, unescape_byte, unescape_char, unescape_mixed, unescape_unicode, MixedUnit, Mode,
 };
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::Span;
-use std::{ascii, fmt, str};
 use tracing::debug;
 
+use crate::ast::{self, LitKind, MetaItemLit, StrStyle};
+use crate::token::{self, Token};
+
 // Escapes a string, represented as a symbol. Reuses the original symbol,
 // avoiding interning, if no changes are required.
 pub fn escape_string_symbol(symbol: Symbol) -> Symbol {

compiler/rustc_ast/src/util/parser.rs

@@ -1,6 +1,7 @@
+use rustc_span::symbol::kw;
+
 use crate::ast::{self, BinOpKind};
 use crate::token::{self, BinOpToken, Token};
-use rustc_span::symbol::kw;
 
 /// Associative operator with precedence.
 ///

compiler/rustc_ast/src/visit.rs

@@ -13,14 +13,13 @@
 //! instance, a walker looking for item names in a module will miss all of
 //! those that are created by the expansion of a macro.
 
-use crate::ast::*;
+pub use rustc_ast_ir::visit::VisitorResult;
-use crate::ptr::P;
+pub use rustc_ast_ir::{try_visit, visit_opt, walk_list, walk_visitable_list};
-
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
-pub use rustc_ast_ir::visit::VisitorResult;
+use crate::ast::*;
-pub use rustc_ast_ir::{try_visit, visit_opt, walk_list, walk_visitable_list};
+use crate::ptr::P;
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum AssocCtxt {

compiler/rustc_ast_lowering/src/asm.rs

@@ -1,13 +1,5 @@
-use crate::{ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt};
+use std::collections::hash_map::Entry;
-
+use std::fmt::Write;
-use super::errors::{
-    AbiSpecifiedMultipleTimes, AttSyntaxOnlyX86, ClobberAbiNotSupported,
-    InlineAsmUnsupportedTarget, InvalidAbiClobberAbi, InvalidAsmTemplateModifierConst,
-    InvalidAsmTemplateModifierLabel, InvalidAsmTemplateModifierRegClass,
-    InvalidAsmTemplateModifierRegClassSub, InvalidAsmTemplateModifierSym, InvalidRegister,
-    InvalidRegisterClass, RegisterClassOnlyClobber, RegisterConflict,
-};
-use super::LoweringContext;
 
 use rustc_ast::ptr::P;
 use rustc_ast::*;
@@ -18,8 +10,16 @@ use rustc_session::parse::feature_err;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 use rustc_target::asm;
-use std::collections::hash_map::Entry;
+
-use std::fmt::Write;
+use super::errors::{
+    AbiSpecifiedMultipleTimes, AttSyntaxOnlyX86, ClobberAbiNotSupported,
+    InlineAsmUnsupportedTarget, InvalidAbiClobberAbi, InvalidAsmTemplateModifierConst,
+    InvalidAsmTemplateModifierLabel, InvalidAsmTemplateModifierRegClass,
+    InvalidAsmTemplateModifierRegClassSub, InvalidAsmTemplateModifierSym, InvalidRegister,
+    InvalidRegisterClass, RegisterClassOnlyClobber, RegisterConflict,
+};
+use super::LoweringContext;
+use crate::{ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt};
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable

compiler/rustc_ast_lowering/src/block.rs

@@ -1,9 +1,9 @@
-use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
 use rustc_ast::{Block, BlockCheckMode, Local, LocalKind, Stmt, StmtKind};
 use rustc_hir as hir;
-
 use smallvec::SmallVec;
 
+use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
+
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     pub(super) fn lower_block(
         &mut self,

compiler/rustc_ast_lowering/src/delegation.rs

@@ -36,23 +36,23 @@
 //! In case of discrepancy with callee function the `NotSupportedDelegation` error will
 //! also be emitted during HIR ty lowering.
 
-use crate::{ImplTraitPosition, ResolverAstLoweringExt};
+use std::iter;
-
-use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
 
 use ast::visit::Visitor;
 use hir::def::{DefKind, PartialRes, Res};
 use hir::{BodyId, HirId};
-use rustc_ast as ast;
 use rustc_ast::*;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, ResolverAstLowering};
-use rustc_span::{symbol::Ident, Span};
+use rustc_span::symbol::Ident;
+use rustc_span::Span;
 use rustc_target::spec::abi;
-use std::iter;
+use {rustc_ast as ast, rustc_hir as hir};
+
+use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
+use crate::{ImplTraitPosition, ResolverAstLoweringExt};
 
 pub(crate) struct DelegationResults<'hir> {
     pub body_id: hir::BodyId,

compiler/rustc_ast_lowering/src/errors.rs

@@ -1,8 +1,8 @@
-use rustc_errors::{
+use rustc_errors::codes::*;
-    codes::*, Diag, DiagArgFromDisplay, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic,
+use rustc_errors::{Diag, DiagArgFromDisplay, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic};
-};
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_span::{symbol::Ident, Span, Symbol};
+use rustc_span::symbol::Ident;
+use rustc_span::{Span, Symbol};
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_generic_type_with_parentheses, code = E0214)]

compiler/rustc_ast_lowering/src/expr.rs

@@ -1,15 +1,5 @@
 use std::assert_matches::assert_matches;
 
-use super::errors::{
-    AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks, BaseExpressionDoubleDot,
-    ClosureCannotBeStatic, CoroutineTooManyParameters,
-    FunctionalRecordUpdateDestructuringAssignment, InclusiveRangeWithNoEnd, MatchArmWithNoBody,
-    NeverPatternWithBody, NeverPatternWithGuard, UnderscoreExprLhsAssign,
-};
-use super::ResolverAstLoweringExt;
-use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
-use crate::errors::YieldInClosure;
-use crate::{FnDeclKind, ImplTraitPosition};
 use rustc_ast::ptr::P as AstP;
 use rustc_ast::*;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -20,10 +10,21 @@ use rustc_middle::span_bug;
 use rustc_session::errors::report_lit_error;
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::DUMMY_SP;
+use rustc_span::{DesugaringKind, Span, DUMMY_SP};
-use rustc_span::{DesugaringKind, Span};
 use thin_vec::{thin_vec, ThinVec};
 
+use super::errors::{
+    AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks, BaseExpressionDoubleDot,
+    ClosureCannotBeStatic, CoroutineTooManyParameters,
+    FunctionalRecordUpdateDestructuringAssignment, InclusiveRangeWithNoEnd, MatchArmWithNoBody,
+    NeverPatternWithBody, NeverPatternWithGuard, UnderscoreExprLhsAssign,
+};
+use super::{
+    ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs, ResolverAstLoweringExt,
+};
+use crate::errors::YieldInClosure;
+use crate::{FnDeclKind, ImplTraitPosition};
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] {
         self.arena.alloc_from_iter(exprs.iter().map(|x| self.lower_expr_mut(x)))

compiler/rustc_ast_lowering/src/format.rs

@@ -1,16 +1,14 @@
-use super::LoweringContext;
 use core::ops::ControlFlow;
-use rustc_ast as ast;
+use std::borrow::Cow;
+
 use rustc_ast::visit::Visitor;
 use rustc_ast::*;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_hir as hir;
+use rustc_span::symbol::{kw, Ident};
-use rustc_span::{
+use rustc_span::{sym, Span, Symbol};
-    sym,
+use {rustc_ast as ast, rustc_hir as hir};
-    symbol::{kw, Ident},
+
-    Span, Symbol,
+use super::LoweringContext;
-};
-use std::borrow::Cow;
 
 impl<'hir> LoweringContext<'_, 'hir> {
     pub(crate) fn lower_format_args(&mut self, sp: Span, fmt: &FormatArgs) -> hir::ExprKind<'hir> {

compiler/rustc_ast_lowering/src/item.rs

@@ -1,8 +1,3 @@
-use super::errors::{InvalidAbi, InvalidAbiReason, InvalidAbiSuggestion, MisplacedRelaxTraitBound};
-use super::ResolverAstLoweringExt;
-use super::{AstOwner, ImplTraitContext, ImplTraitPosition};
-use super::{FnDeclKind, LoweringContext, ParamMode};
-
 use rustc_ast::ptr::P;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
@@ -22,6 +17,12 @@ use smallvec::{smallvec, SmallVec};
 use thin_vec::ThinVec;
 use tracing::instrument;
 
+use super::errors::{InvalidAbi, InvalidAbiReason, InvalidAbiSuggestion, MisplacedRelaxTraitBound};
+use super::{
+    AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
+    ResolverAstLoweringExt,
+};
+
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
     pub(super) resolver: &'a mut ResolverAstLowering,

compiler/rustc_ast_lowering/src/lib.rs

@@ -39,7 +39,8 @@
 #![feature(rustdoc_internals)]
 // tidy-alphabetical-end
 
-use crate::errors::{AssocTyParentheses, AssocTyParenthesesSub, MisplacedImplTrait};
+use std::collections::hash_map::Entry;
+
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, *};
@@ -53,9 +54,9 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, StashKey};
 use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{LocalDefId, LocalDefIdMap, CRATE_DEF_ID, LOCAL_CRATE};
-use rustc_hir::{self as hir};
 use rustc_hir::{
-    ConstArg, GenericArg, HirId, ItemLocalMap, MissingLifetimeKind, ParamName, TraitCandidate,
+    self as hir, ConstArg, GenericArg, HirId, ItemLocalMap, MissingLifetimeKind, ParamName,
+    TraitCandidate,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
@@ -65,10 +66,11 @@ use rustc_session::parse::{add_feature_diagnostics, feature_err};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{DesugaringKind, Span, DUMMY_SP};
 use smallvec::{smallvec, SmallVec};
-use std::collections::hash_map::Entry;
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
 
+use crate::errors::{AssocTyParentheses, AssocTyParenthesesSub, MisplacedImplTrait};
+
 macro_rules! arena_vec {
     ($this:expr; $($x:expr),*) => (
         $this.arena.alloc_from_iter([$($x),*])

compiler/rustc_ast_lowering/src/lifetime_collector.rs

@@ -1,4 +1,3 @@
-use super::ResolverAstLoweringExt;
 use rustc_ast::visit::{self, BoundKind, LifetimeCtxt, Visitor};
 use rustc_ast::{GenericBounds, Lifetime, NodeId, PathSegment, PolyTraitRef, Ty, TyKind};
 use rustc_data_structures::fx::FxIndexSet;
@@ -8,6 +7,8 @@ use rustc_middle::ty::ResolverAstLowering;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 
+use super::ResolverAstLoweringExt;
+
 struct LifetimeCollectVisitor<'ast> {
     resolver: &'ast ResolverAstLowering,
     current_binders: Vec<NodeId>,

compiler/rustc_ast_lowering/src/pat.rs

@@ -1,17 +1,17 @@
-use super::errors::{
-    ArbitraryExpressionInPattern, ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding,
-};
-use super::ResolverAstLoweringExt;
-use super::{ImplTraitContext, LoweringContext, ParamMode};
-use crate::ImplTraitPosition;
-
 use rustc_ast::ptr::P;
 use rustc_ast::*;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
+use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
-use rustc_span::{source_map::Spanned, Span};
+use rustc_span::Span;
+
+use super::errors::{
+    ArbitraryExpressionInPattern, ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding,
+};
+use super::{ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt};
+use crate::ImplTraitPosition;
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir hir::Pat<'hir> {

compiler/rustc_ast_lowering/src/path.rs

@@ -1,13 +1,3 @@
-use crate::ImplTraitPosition;
-
-use super::errors::{
-    AsyncBoundNotOnTrait, AsyncBoundOnlyForFnTraits, BadReturnTypeNotation,
-    GenericTypeWithParentheses, UseAngleBrackets,
-};
-use super::ResolverAstLoweringExt;
-use super::{GenericArgsCtor, LifetimeRes, ParenthesizedGenericArgs};
-use super::{ImplTraitContext, LoweringContext, ParamMode};
-
 use rustc_ast::{self as ast, *};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir as hir;
@@ -17,10 +7,19 @@ use rustc_hir::GenericArg;
 use rustc_middle::span_bug;
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::{BytePos, DesugaringKind, Span, Symbol, DUMMY_SP};
-
 use smallvec::{smallvec, SmallVec};
 use tracing::{debug, instrument};
 
+use super::errors::{
+    AsyncBoundNotOnTrait, AsyncBoundOnlyForFnTraits, BadReturnTypeNotation,
+    GenericTypeWithParentheses, UseAngleBrackets,
+};
+use super::{
+    GenericArgsCtor, ImplTraitContext, LifetimeRes, LoweringContext, ParamMode,
+    ParenthesizedGenericArgs, ResolverAstLoweringExt,
+};
+use crate::ImplTraitPosition;
+
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     #[instrument(level = "trace", skip(self))]
     pub(crate) fn lower_qpath(

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -16,6 +16,9 @@
 //! constructions produced by proc macros. This pass is only intended for simple checks that do not
 //! require name resolution or type checking, or other kinds of complex analysis.
 
+use std::mem;
+use std::ops::{Deref, DerefMut};
+
 use itertools::{Either, Itertools};
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{walk_list, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor};
@@ -34,8 +37,6 @@ use rustc_session::Session;
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::Span;
 use rustc_target::spec::abi;
-use std::mem;
-use std::ops::{Deref, DerefMut};
 use thin_vec::thin_vec;
 
 use crate::errors::{self, TildeConstReason};

compiler/rustc_ast_passes/src/errors.rs

@@ -1,11 +1,11 @@
 //! Errors emitted by ast_passes.
 
 use rustc_ast::ParamKindOrd;
-use rustc_errors::{
+use rustc_errors::codes::*;
-    codes::*, Applicability, Diag, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic,
+use rustc_errors::{Applicability, Diag, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic};
-};
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_span::{symbol::Ident, Span, Symbol};
+use rustc_span::symbol::Ident;
+use rustc_span::{Span, Symbol};
 
 use crate::fluent_generated as fluent;
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,7 +1,6 @@
 use rustc_ast as ast;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
-use rustc_ast::{attr, NodeId};
+use rustc_ast::{attr, token, NodeId, PatKind};
-use rustc_ast::{token, PatKind};
 use rustc_feature::{AttributeGate, BuiltinAttribute, Features, GateIssue, BUILTIN_ATTRIBUTE_MAP};
 use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
 use rustc_session::Session;

compiler/rustc_ast_pretty/src/helpers.rs

@@ -1,6 +1,7 @@
-use crate::pp::Printer;
 use std::borrow::Cow;
 
+use crate::pp::Printer;
+
 impl Printer {
     pub fn word_space<W: Into<Cow<'static, str>>>(&mut self, w: W) {
         self.word(w);

compiler/rustc_ast_pretty/src/pp.rs

@@ -135,11 +135,11 @@
 mod convenience;
 mod ring;
 
-use ring::RingBuffer;
 use std::borrow::Cow;
-use std::cmp;
 use std::collections::VecDeque;
-use std::iter;
+use std::{cmp, iter};
+
+use ring::RingBuffer;
 
 /// How to break. Described in more detail in the module docs.
 #[derive(Clone, Copy, PartialEq)]

compiler/rustc_ast_pretty/src/pp/convenience.rs

@@ -1,6 +1,7 @@
-use crate::pp::{BeginToken, BreakToken, Breaks, IndentStyle, Printer, Token, SIZE_INFINITY};
 use std::borrow::Cow;
 
+use crate::pp::{BeginToken, BreakToken, Breaks, IndentStyle, Printer, Token, SIZE_INFINITY};
+
 impl Printer {
     /// "raw box"
     pub fn rbox(&mut self, indent: isize, breaks: Breaks) {

compiler/rustc_ast_pretty/src/pprust/mod.rs

@@ -2,13 +2,12 @@
 mod tests;
 
 pub mod state;
-pub use state::{print_crate, AnnNode, Comments, PpAnn, PrintState, State};
+use std::borrow::Cow;
 
 use rustc_ast as ast;
 use rustc_ast::token::{Nonterminal, Token, TokenKind};
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
-
+pub use state::{print_crate, AnnNode, Comments, PpAnn, PrintState, State};
-use std::borrow::Cow;
 
 pub fn nonterminal_to_string(nt: &Nonterminal) -> String {
     State::new().nonterminal_to_string(nt)

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -6,9 +6,8 @@ mod expr;
 mod fixup;
 mod item;
 
-use crate::pp::Breaks::{Consistent, Inconsistent};
+use std::borrow::Cow;
-use crate::pp::{self, Breaks};
+
-use crate::pprust::state::fixup::FixupContext;
 use ast::TraitBoundModifiers;
 use rustc_ast::attr::AttrIdGenerator;
 use rustc_ast::ptr::P;
@@ -16,18 +15,21 @@ use rustc_ast::token::{self, BinOpToken, CommentKind, Delimiter, Nonterminal, To
 use rustc_ast::tokenstream::{Spacing, TokenStream, TokenTree};
 use rustc_ast::util::classify;
 use rustc_ast::util::comments::{Comment, CommentStyle};
-use rustc_ast::{self as ast, AttrArgs, AttrArgsEq, BlockCheckMode, PatKind, Safety};
+use rustc_ast::{
-use rustc_ast::{attr, BindingMode, ByRef, DelimArgs, RangeEnd, RangeSyntax, Term};
+    self as ast, attr, AttrArgs, AttrArgsEq, BindingMode, BlockCheckMode, ByRef, DelimArgs,
-use rustc_ast::{GenericArg, GenericBound, SelfKind};
+    GenericArg, GenericBound, InlineAsmOperand, InlineAsmOptions, InlineAsmRegOrRegClass,
-use rustc_ast::{InlineAsmOperand, InlineAsmRegOrRegClass};
+    InlineAsmTemplatePiece, PatKind, RangeEnd, RangeSyntax, Safety, SelfKind, Term,
-use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
+};
 use rustc_span::edition::Edition;
 use rustc_span::source_map::{SourceMap, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, IdentPrinter, Symbol};
 use rustc_span::{BytePos, CharPos, FileName, Pos, Span, DUMMY_SP};
-use std::borrow::Cow;
 use thin_vec::ThinVec;
 
+use crate::pp::Breaks::{Consistent, Inconsistent};
+use crate::pp::{self, Breaks};
+use crate::pprust::state::fixup::FixupContext;
+
 pub enum MacHeader<'a> {
     Path(&'a ast::Path),
     Keyword(&'static str),
@@ -290,8 +292,7 @@ pub fn print_crate<'a>(
 fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
     use token::*;
     use Delimiter::*;
-    use TokenTree::Delimited as Del;
+    use TokenTree::{Delimited as Del, Token as Tok};
-    use TokenTree::Token as Tok;
 
     fn is_punct(tt: &TokenTree) -> bool {
         matches!(tt, TokenTree::Token(tok, _) if tok.is_punct())

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -1,19 +1,19 @@
-use crate::pp::Breaks::Inconsistent;
+use std::fmt::Write;
-use crate::pprust::state::fixup::FixupContext;
+
-use crate::pprust::state::{AnnNode, PrintState, State, INDENT_UNIT};
 use ast::{ForLoopKind, MatchKind};
 use itertools::{Itertools, Position};
 use rustc_ast::ptr::P;
-use rustc_ast::token;
 use rustc_ast::util::classify;
 use rustc_ast::util::literal::escape_byte_str_symbol;
 use rustc_ast::util::parser::{self, AssocOp, Fixity};
-use rustc_ast::{self as ast, BlockCheckMode};
 use rustc_ast::{
-    FormatAlignment, FormatArgPosition, FormatArgsPiece, FormatCount, FormatDebugHex, FormatSign,
+    self as ast, token, BlockCheckMode, FormatAlignment, FormatArgPosition, FormatArgsPiece,
-    FormatTrait,
+    FormatCount, FormatDebugHex, FormatSign, FormatTrait,
 };
-use std::fmt::Write;
+
+use crate::pp::Breaks::Inconsistent;
+use crate::pprust::state::fixup::FixupContext;
+use crate::pprust::state::{AnnNode, PrintState, State, INDENT_UNIT};
 
 impl<'a> State<'a> {
     fn print_else(&mut self, els: Option<&ast::Expr>) {

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -1,7 +1,3 @@
-use crate::pp::Breaks::Inconsistent;
-use crate::pprust::state::fixup::FixupContext;
-use crate::pprust::state::{AnnNode, PrintState, State, INDENT_UNIT};
-
 use ast::StaticItem;
 use itertools::{Itertools, Position};
 use rustc_ast as ast;
@@ -9,6 +5,10 @@ use rustc_ast::ptr::P;
 use rustc_ast::ModKind;
 use rustc_span::symbol::Ident;
 
+use crate::pp::Breaks::Inconsistent;
+use crate::pprust::state::fixup::FixupContext;
+use crate::pprust::state::{AnnNode, PrintState, State, INDENT_UNIT};
+
 enum DelegationKind<'a> {
     Single,
     List(&'a [(Ident, Option<Ident>)]),

compiler/rustc_ast_pretty/src/pprust/tests.rs

@@ -1,11 +1,10 @@
-use super::*;
-
 use rustc_ast as ast;
-use rustc_span::create_default_session_globals_then;
 use rustc_span::symbol::Ident;
-use rustc_span::DUMMY_SP;
+use rustc_span::{create_default_session_globals_then, DUMMY_SP};
 use thin_vec::ThinVec;
 
+use super::*;
+
 fn fun_to_string(
     decl: &ast::FnDecl,
     header: ast::FnHeader,

compiler/rustc_attr/src/builtin.rs

@@ -1,8 +1,12 @@
 //! Parsing and validation of builtin attributes
 
+use std::num::NonZero;
+
 use rustc_abi::Align;
-use rustc_ast::{self as ast, attr};
+use rustc_ast::{
-use rustc_ast::{Attribute, LitKind, MetaItem, MetaItemKind, MetaItemLit, NestedMetaItem, NodeId};
+    self as ast, attr, Attribute, LitKind, MetaItem, MetaItemKind, MetaItemLit, NestedMetaItem,
+    NodeId,
+};
 use rustc_ast_pretty::pprust;
 use rustc_errors::ErrorGuaranteed;
 use rustc_feature::{find_gated_cfg, is_builtin_attr_name, Features, GatedCfg};
@@ -13,8 +17,8 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::parse::feature_err;
 use rustc_session::{RustcVersion, Session};
 use rustc_span::hygiene::Transparency;
-use rustc_span::{symbol::sym, symbol::Symbol, Span};
+use rustc_span::symbol::{sym, Symbol};
-use std::num::NonZero;
+use rustc_span::Span;
 
 use crate::session_diagnostics::{self, IncorrectReprFormatGenericCause};
 

compiler/rustc_attr/src/lib.rs

@@ -15,12 +15,10 @@ mod builtin;
 mod session_diagnostics;
 
 pub use builtin::*;
+pub use rustc_ast::attr::*;
+pub(crate) use rustc_session::HashStableContext;
 pub use IntType::*;
 pub use ReprAttr::*;
 pub use StabilityLevel::*;
 
-pub use rustc_ast::attr::*;
-
-pub(crate) use rustc_session::HashStableContext;
-
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }

compiler/rustc_attr/src/session_diagnostics.rs

@@ -1,13 +1,12 @@
 use std::num::IntErrorKind;
 
 use rustc_ast as ast;
-use rustc_errors::DiagCtxtHandle;
+use rustc_errors::codes::*;
-use rustc_errors::{codes::*, Applicability, Diag, Diagnostic, EmissionGuarantee, Level};
+use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 
-use crate::fluent_generated as fluent;
+use crate::{fluent_generated as fluent, UnsupportedLiteralReason};
-use crate::UnsupportedLiteralReason;
 
 #[derive(Diagnostic)]
 #[diag(attr_expected_one_cfg_pattern, code = E0536)]

compiler/rustc_borrowck/src/borrow_set.rs

@@ -1,16 +1,17 @@
-use crate::path_utils::allow_two_phase_borrow;
+use std::fmt;
-use crate::place_ext::PlaceExt;
+use std::ops::Index;
-use crate::BorrowIndex;
+
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_index::bit_set::BitSet;
-use rustc_middle::mir::traversal;
 use rustc_middle::mir::visit::{MutatingUseContext, NonUseContext, PlaceContext, Visitor};
-use rustc_middle::mir::{self, Body, Local, Location};
+use rustc_middle::mir::{self, traversal, Body, Local, Location};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{RegionVid, TyCtxt};
 use rustc_mir_dataflow::move_paths::MoveData;
-use std::fmt;
+
-use std::ops::Index;
+use crate::path_utils::allow_two_phase_borrow;
+use crate::place_ext::PlaceExt;
+use crate::BorrowIndex;
 
 pub struct BorrowSet<'tcx> {
     /// The fundamental map relating bitvector indexes to the borrows

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -1,8 +1,8 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
-use rustc_errors::Applicability;
+use rustc_errors::codes::*;
-use rustc_errors::{codes::*, struct_span_code_err, Diag, DiagCtxtHandle};
+use rustc_errors::{struct_span_code_err, Applicability, Diag, DiagCtxtHandle};
 use rustc_hir as hir;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, Ty, TyCtxt};

compiler/rustc_borrowck/src/constraints/graph.rs

@@ -4,11 +4,8 @@ use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{RegionVid, VarianceDiagInfo};
 use rustc_span::DUMMY_SP;
 
-use crate::{
+use crate::constraints::{OutlivesConstraint, OutlivesConstraintIndex, OutlivesConstraintSet};
-    constraints::OutlivesConstraintIndex,
+use crate::type_check::Locations;
-    constraints::{OutlivesConstraint, OutlivesConstraintSet},
-    type_check::Locations,
-};
 
 /// The construct graph organizes the constraints by their end-points.
 /// It can be used to view a `R1: R2` constraint as either an edge `R1

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -1,12 +1,14 @@
-use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker};
+use std::fmt;
-use crate::type_check::Locations;
+use std::ops::Index;
-use crate::universal_regions::UniversalRegions;
+
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{RegionVid, TyCtxt, VarianceDiagInfo};
 use rustc_span::Span;
-use std::fmt;
+
-use std::ops::Index;
+use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker};
+use crate::type_check::Locations;
+use crate::universal_regions::UniversalRegions;
 
 pub(crate) mod graph;
 

compiler/rustc_borrowck/src/consumers.rs

@@ -1,24 +1,22 @@
 //! This file provides API for compiler consumers.
 
+use std::rc::Rc;
+
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::mir::{Body, Promoted};
 use rustc_middle::ty::TyCtxt;
-use std::rc::Rc;
 
+pub use super::constraints::OutlivesConstraint;
+pub use super::dataflow::{calculate_borrows_out_of_scope_at_location, BorrowIndex, Borrows};
+pub use super::facts::{AllFacts as PoloniusInput, RustcFacts};
+pub use super::location::{LocationTable, RichLocation};
+pub use super::nll::PoloniusOutput;
+pub use super::place_ext::PlaceExt;
+pub use super::places_conflict::{places_conflict, PlaceConflictBias};
+pub use super::region_infer::RegionInferenceContext;
 use crate::borrow_set::BorrowSet;
 
-pub use super::{
-    constraints::OutlivesConstraint,
-    dataflow::{calculate_borrows_out_of_scope_at_location, BorrowIndex, Borrows},
-    facts::{AllFacts as PoloniusInput, RustcFacts},
-    location::{LocationTable, RichLocation},
-    nll::PoloniusOutput,
-    place_ext::PlaceExt,
-    places_conflict::{places_conflict, PlaceConflictBias},
-    region_infer::RegionInferenceContext,
-};
-
 /// Options determining the output behavior of [`get_body_with_borrowck_facts`].
 ///
 /// If executing under `-Z polonius` the choice here has no effect, and everything as if

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,16 +1,15 @@
+use std::fmt;
+
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::graph;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{
     self, BasicBlock, Body, CallReturnPlaces, Location, Place, TerminatorEdges,
 };
-use rustc_middle::ty::RegionVid;
+use rustc_middle::ty::{RegionVid, TyCtxt};
-use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::fmt::DebugWithContext;
 use rustc_mir_dataflow::impls::{EverInitializedPlaces, MaybeUninitializedPlaces};
-use rustc_mir_dataflow::ResultsVisitable;
+use rustc_mir_dataflow::{Analysis, AnalysisDomain, GenKill, Results, ResultsVisitable};
-use rustc_mir_dataflow::{fmt::DebugWithContext, GenKill};
-use rustc_mir_dataflow::{Analysis, AnalysisDomain, Results};
-use std::fmt;
 
 use crate::{places_conflict, BorrowSet, PlaceConflictBias, PlaceExt, RegionInferenceContext};
 

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -1,17 +1,18 @@
+use std::fmt;
+use std::rc::Rc;
+
 use rustc_errors::Diag;
 use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::canonical::Canonical;
-use rustc_infer::infer::region_constraints::Constraint;
+use rustc_infer::infer::region_constraints::{Constraint, RegionConstraintData};
-use rustc_infer::infer::region_constraints::RegionConstraintData;
+use rustc_infer::infer::{
-use rustc_infer::infer::RegionVariableOrigin;
+    InferCtxt, RegionResolutionError, RegionVariableOrigin, SubregionOrigin, TyCtxtInferExt as _,
-use rustc_infer::infer::{InferCtxt, RegionResolutionError, SubregionOrigin, TyCtxtInferExt as _};
+};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::ty::error::TypeError;
-use rustc_middle::ty::RePlaceholder;
+use rustc_middle::ty::{
-use rustc_middle::ty::Region;
+    self, RePlaceholder, Region, RegionVid, Ty, TyCtxt, TypeFoldable, UniverseIndex,
-use rustc_middle::ty::RegionVid;
+};
-use rustc_middle::ty::UniverseIndex;
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_span::Span;
 use rustc_trait_selection::error_reporting::infer::nice_region_error::NiceRegionError;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
@@ -19,13 +20,10 @@ use rustc_trait_selection::traits::query::type_op;
 use rustc_trait_selection::traits::ObligationCtxt;
 use rustc_traits::{type_op_ascribe_user_type_with_span, type_op_prove_predicate_with_cause};
 
-use std::fmt;
-use std::rc::Rc;
-
 use crate::region_infer::values::RegionElement;
-use crate::session_diagnostics::HigherRankedErrorCause;
+use crate::session_diagnostics::{
-use crate::session_diagnostics::HigherRankedLifetimeError;
+    HigherRankedErrorCause, HigherRankedLifetimeError, HigherRankedSubtypeError,
-use crate::session_diagnostics::HigherRankedSubtypeError;
+};
 use crate::MirBorrowckCtxt;
 
 #[derive(Clone)]

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -3,25 +3,27 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
+use std::iter;
+use std::ops::ControlFlow;
+
 use either::Either;
 use hir::{ClosureKind, Path};
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{codes::*, struct_span_code_err, Applicability, Diag, MultiSpan};
+use rustc_errors::codes::*;
+use rustc_errors::{struct_span_code_err, Applicability, Diag, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_block, walk_expr, Map, Visitor};
-use rustc_hir::{CoroutineDesugaring, PatField};
+use rustc_hir::{CoroutineDesugaring, CoroutineKind, CoroutineSource, LangItem, PatField};
-use rustc_hir::{CoroutineKind, CoroutineSource, LangItem};
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::tcx::PlaceTy;
-use rustc_middle::mir::VarDebugInfoContents;
 use rustc_middle::mir::{
     self, AggregateKind, BindingForm, BorrowKind, CallSource, ClearCrossCrate, ConstraintCategory,
     FakeBorrowKind, FakeReadCause, LocalDecl, LocalInfo, LocalKind, Location, MutBorrowKind,
     Operand, Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
-    TerminatorKind, VarBindingForm,
+    TerminatorKind, VarBindingForm, VarDebugInfoContents,
 };
 use rustc_middle::ty::print::PrintTraitRefExt as _;
 use rustc_middle::ty::{
@@ -30,8 +32,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::util::CallKind;
 use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
-use rustc_span::def_id::DefId;
+use rustc_span::def_id::{DefId, LocalDefId};
-use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::{BytePos, Span, Symbol};
@@ -39,22 +40,14 @@ use rustc_trait_selection::error_reporting::traits::FindExprBySpan;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCause, ObligationCtxt};
-use std::iter;
-use std::ops::ControlFlow;
 
-use crate::borrow_set::TwoPhaseActivation;
+use super::explain_borrow::{BorrowExplanation, LaterUseKind};
-use crate::borrowck_errors;
+use super::{DescribePlaceOpt, RegionName, RegionNameSource, UseSpans};
+use crate::borrow_set::{BorrowData, TwoPhaseActivation};
 use crate::diagnostics::conflict_errors::StorageDeadOrDrop::LocalStorageDead;
-use crate::diagnostics::{find_all_local_uses, CapturedMessageOpt};
+use crate::diagnostics::{find_all_local_uses, CapturedMessageOpt, Instance};
-use crate::{
+use crate::prefixes::IsPrefixOf;
-    borrow_set::BorrowData, diagnostics::Instance, prefixes::IsPrefixOf,
+use crate::{borrowck_errors, InitializationRequiringAction, MirBorrowckCtxt, WriteKind};
-    InitializationRequiringAction, MirBorrowckCtxt, WriteKind,
-};
-
-use super::{
-    explain_borrow::{BorrowExplanation, LaterUseKind},
-    DescribePlaceOpt, RegionName, RegionNameSource, UseSpans,
-};
 
 #[derive(Debug)]
 struct MoveSite {

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -19,13 +19,11 @@ use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, DesugaringKind, Span};
 use rustc_trait_selection::error_reporting::traits::FindExprBySpan;
 
-use crate::region_infer::{BlameConstraint, ExtraConstraintInfo};
-use crate::{
-    borrow_set::BorrowData, nll::ConstraintDescription, region_infer::Cause, MirBorrowckCtxt,
-    WriteKind,
-};
-
 use super::{find_use, RegionName, UseSpans};
+use crate::borrow_set::BorrowData;
+use crate::nll::ConstraintDescription;
+use crate::region_infer::{BlameConstraint, Cause, ExtraConstraintInfo};
+use crate::{MirBorrowckCtxt, WriteKind};
 
 #[derive(Debug)]
 pub(crate) enum BorrowExplanation<'tcx> {

compiler/rustc_borrowck/src/diagnostics/find_use.rs

@@ -1,15 +1,14 @@
 use std::collections::VecDeque;
 use std::rc::Rc;
 
-use crate::{
-    def_use::{self, DefUse},
-    region_infer::{Cause, RegionInferenceContext},
-};
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_middle::mir::visit::{MirVisitable, PlaceContext, Visitor};
 use rustc_middle::mir::{self, Body, Local, Location};
 use rustc_middle::ty::{RegionVid, TyCtxt};
 
+use crate::def_use::{self, DefUse};
+use crate::region_infer::{Cause, RegionInferenceContext};
+
 pub(crate) fn find<'tcx>(
     body: &Body<'tcx>,
     regioncx: &Rc<RegionInferenceContext<'tcx>>,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -1,14 +1,8 @@
 //! Borrow checker diagnostics.
 
-use crate::session_diagnostics::{
+use rustc_errors::{Applicability, Diag, MultiSpan};
-    CaptureArgLabel, CaptureReasonLabel, CaptureReasonNote, CaptureReasonSuggest, CaptureVarCause,
-    CaptureVarKind, CaptureVarPathUseCause, OnClosureNote,
-};
-use rustc_errors::MultiSpan;
-use rustc_errors::{Applicability, Diag};
 use rustc_hir::def::{CtorKind, Namespace};
-use rustc_hir::CoroutineKind;
+use rustc_hir::{self as hir, CoroutineKind, LangItem};
-use rustc_hir::{self as hir, LangItem};
 use rustc_index::IndexSlice;
 use rustc_infer::infer::BoundRegionConversionTime;
 use rustc_infer::traits::SelectionError;
@@ -25,7 +19,8 @@ use rustc_middle::util::{call_kind, CallDesugaringKind};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Spanned;
-use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
+use rustc_span::symbol::sym;
+use rustc_span::{Span, Symbol, DUMMY_SP};
 use rustc_target::abi::{FieldIdx, VariantIdx};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -33,10 +28,13 @@ use rustc_trait_selection::traits::{
     type_known_to_meet_bound_modulo_regions, FulfillmentErrorCode,
 };
 
-use crate::fluent_generated as fluent;
-
 use super::borrow_set::BorrowData;
 use super::MirBorrowckCtxt;
+use crate::fluent_generated as fluent;
+use crate::session_diagnostics::{
+    CaptureArgLabel, CaptureReasonLabel, CaptureReasonNote, CaptureReasonSuggest, CaptureVarCause,
+    CaptureVarKind, CaptureVarPathUseCause, OnClosureNote,
+};
 
 mod find_all_local_uses;
 mod find_use;
@@ -599,8 +597,9 @@ impl UseSpans<'_> {
         err: &mut Diag<'_>,
         action: crate::InitializationRequiringAction,
     ) {
-        use crate::InitializationRequiringAction::*;
         use CaptureVarPathUseCause::*;
+
+        use crate::InitializationRequiringAction::*;
         if let UseSpans::ClosureUse { closure_kind, path_span, .. } = self {
             match closure_kind {
                 hir::ClosureKind::Coroutine(_) => {

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -11,8 +11,7 @@ use rustc_mir_dataflow::move_paths::{LookupResult, MovePathIndex};
 use rustc_span::{BytePos, ExpnKind, MacroKind, Span};
 use rustc_trait_selection::error_reporting::traits::FindExprBySpan;
 
-use crate::diagnostics::CapturedMessageOpt;
+use crate::diagnostics::{CapturedMessageOpt, DescribePlaceOpt, UseSpans};
-use crate::diagnostics::{DescribePlaceOpt, UseSpans};
 use crate::prefixes::PrefixSet;
 use crate::MirBorrowckCtxt;
 

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -2,17 +2,18 @@
 #![allow(rustc::untranslatable_diagnostic)]
 
 use core::ops::ControlFlow;
+
 use hir::{ExprKind, Param};
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{self as hir, BindingMode, ByRef, Node};
 use rustc_middle::bug;
-use rustc_middle::mir::{Mutability, Place, PlaceRef, ProjectionElem};
+use rustc_middle::hir::place::PlaceBase;
-use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt, Upcast};
+use rustc_middle::mir::{
-use rustc_middle::{
+    self, BindingForm, Local, LocalDecl, LocalInfo, LocalKind, Location, Mutability, Place,
-    hir::place::PlaceBase,
+    PlaceRef, ProjectionElem,
-    mir::{self, BindingForm, Local, LocalDecl, LocalInfo, LocalKind, Location},
 };
+use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt, Upcast};
 use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, BytePos, DesugaringKind, Span};
 use rustc_target::abi::FieldIdx;
@@ -847,10 +848,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
     // Attempt to search similar mutable associated items for suggestion.
     // In the future, attempt in all path but initially for RHS of for_loop
     fn suggest_similar_mut_method_for_for_loop(&self, err: &mut Diag<'_>, span: Span) {
-        use hir::{
+        use hir::ExprKind::{AddrOf, Block, Call, MethodCall};
-            BorrowKind, Expr,
+        use hir::{BorrowKind, Expr};
-            ExprKind::{AddrOf, Block, Call, MethodCall},
-        };
 
         let hir_map = self.infcx.tcx.hir();
         struct Finder {

compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs

@@ -4,15 +4,15 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
+use std::collections::BTreeMap;
+
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::Diag;
 use rustc_middle::ty::RegionVid;
 use smallvec::SmallVec;
-use std::collections::BTreeMap;
-
-use crate::MirBorrowckCtxt;
 
 use super::{ErrorConstraintInfo, RegionName, RegionNameSource};
+use crate::MirBorrowckCtxt;
 
 /// The different things we could suggest.
 enum SuggestedConstraint {

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -14,10 +14,7 @@ use rustc_infer::infer::{NllRegionVariableOrigin, RelateParamBound};
 use rustc_middle::bug;
 use rustc_middle::hir::place::PlaceBase;
 use rustc_middle::mir::{ConstraintCategory, ReturnConstraint};
-use rustc_middle::ty::GenericArgs;
+use rustc_middle::ty::{self, GenericArgs, Region, RegionVid, Ty, TyCtxt, TypeVisitor};
-use rustc_middle::ty::TypeVisitor;
-use rustc_middle::ty::{self, RegionVid, Ty};
-use rustc_middle::ty::{Region, TyCtxt};
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 use rustc_trait_selection::error_reporting::infer::nice_region_error::{
@@ -29,20 +26,16 @@ use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCtxt};
 
-use crate::borrowck_errors;
+use super::{OutlivesSuggestionBuilder, RegionName, RegionNameSource};
+use crate::nll::ConstraintDescription;
+use crate::region_infer::values::RegionElement;
+use crate::region_infer::{BlameConstraint, ExtraConstraintInfo, TypeTest};
 use crate::session_diagnostics::{
     FnMutError, FnMutReturnTypeErr, GenericDoesNotLiveLongEnough, LifetimeOutliveErr,
     LifetimeReturnCategoryErr, RequireStaticErr, VarHereDenote,
 };
-
+use crate::universal_regions::DefiningTy;
-use super::{OutlivesSuggestionBuilder, RegionName, RegionNameSource};
+use crate::{borrowck_errors, MirBorrowckCtxt};
-use crate::region_infer::{BlameConstraint, ExtraConstraintInfo};
-use crate::{
-    nll::ConstraintDescription,
-    region_infer::{values::RegionElement, TypeTest},
-    universal_regions::DefiningTy,
-    MirBorrowckCtxt,
-};
 
 impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
     fn description(&self) -> &'static str {

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -9,14 +9,14 @@ use rustc_errors::Diag;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::ty::print::RegionHighlightMode;
-use rustc_middle::ty::{self, RegionVid, Ty};
+use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, RegionVid, Ty};
-use rustc_middle::ty::{GenericArgKind, GenericArgsRef};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 
-use crate::{universal_regions::DefiningTy, MirBorrowckCtxt};
+use crate::universal_regions::DefiningTy;
+use crate::MirBorrowckCtxt;
 
 /// A name for a particular region used in emitting diagnostics. This name could be a generated
 /// name like `'1`, a name used by the user like `'a`, or a name like `'static`.

compiler/rustc_borrowck/src/diagnostics/var_name.rs

@@ -1,10 +1,11 @@
-use crate::region_infer::RegionInferenceContext;
 use rustc_index::IndexSlice;
 use rustc_middle::mir::{Body, Local};
 use rustc_middle::ty::{self, RegionVid, TyCtxt};
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
+use crate::region_infer::RegionInferenceContext;
+
 impl<'tcx> RegionInferenceContext<'tcx> {
     pub(crate) fn get_var_name_and_span_for_region(
         &self,

compiler/rustc_borrowck/src/facts.rs

@@ -1,17 +1,18 @@
-use crate::location::{LocationIndex, LocationTable};
-use crate::BorrowIndex;
-use polonius_engine::AllFacts as PoloniusFacts;
-use polonius_engine::Atom;
-use rustc_macros::extension;
-use rustc_middle::mir::Local;
-use rustc_middle::ty::{RegionVid, TyCtxt};
-use rustc_mir_dataflow::move_paths::MovePathIndex;
 use std::error::Error;
 use std::fmt::Debug;
 use std::fs::{self, File};
 use std::io::{BufWriter, Write};
 use std::path::Path;
 
+use polonius_engine::{AllFacts as PoloniusFacts, Atom};
+use rustc_macros::extension;
+use rustc_middle::mir::Local;
+use rustc_middle::ty::{RegionVid, TyCtxt};
+use rustc_mir_dataflow::move_paths::MovePathIndex;
+
+use crate::location::{LocationIndex, LocationTable};
+use crate::BorrowIndex;
+
 #[derive(Copy, Clone, Debug)]
 pub struct RustcFacts;
 

compiler/rustc_borrowck/src/lib.rs

@@ -17,6 +17,13 @@
 #[macro_use]
 extern crate tracing;
 
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::rc::Rc;
+
+use consumers::{BodyWithBorrowckFacts, ConsumerOptions};
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_errors::Diag;
@@ -24,40 +31,31 @@ use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::bit_set::{BitSet, ChunkedBitSet};
 use rustc_index::{IndexSlice, IndexVec};
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::{
-use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin};
+    InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin, TyCtxtInferExt,
+};
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::*;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, ParamEnv, RegionVid, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_session::lint::builtin::UNUSED_MUT;
-use rustc_span::{Span, Symbol};
-use rustc_target::abi::FieldIdx;
-
-use smallvec::SmallVec;
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::marker::PhantomData;
-use std::ops::Deref;
-use std::rc::Rc;
-
 use rustc_mir_dataflow::impls::{
     EverInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces,
 };
-use rustc_mir_dataflow::move_paths::{InitIndex, MoveOutIndex, MovePathIndex};
+use rustc_mir_dataflow::move_paths::{
-use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveData};
+    InitIndex, InitLocation, LookupResult, MoveData, MoveOutIndex, MovePathIndex,
-use rustc_mir_dataflow::Analysis;
+};
-use rustc_mir_dataflow::MoveDataParamEnv;
+use rustc_mir_dataflow::{Analysis, MoveDataParamEnv};
-
+use rustc_session::lint::builtin::UNUSED_MUT;
-use crate::session_diagnostics::VarNeedNotMut;
+use rustc_span::{Span, Symbol};
+use rustc_target::abi::FieldIdx;
+use smallvec::SmallVec;
 
 use self::diagnostics::{AccessKind, IllegalMoveOriginKind, MoveError, RegionName};
 use self::location::LocationTable;
-use self::prefixes::PrefixSet;
-use consumers::{BodyWithBorrowckFacts, ConsumerOptions};
-
 use self::path_utils::*;
+use self::prefixes::PrefixSet;
+use crate::session_diagnostics::VarNeedNotMut;
 
 pub mod borrow_set;
 mod borrowck_errors;

compiler/rustc_borrowck/src/member_constraints.rs

@@ -1,11 +1,12 @@
+use std::hash::Hash;
+use std::ops::Index;
+
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::infer::MemberConstraint;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
-use std::hash::Hash;
-use std::ops::Index;
 
 /// Compactly stores a set of `R0 member of [R1...Rn]` constraints,
 /// indexed by the region `R0`.

compiler/rustc_borrowck/src/nll.rs

@@ -1,11 +1,18 @@
 //! The entry point of the NLL borrow checker.
 
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::str::FromStr;
+use std::{env, io};
+
 use polonius_engine::{Algorithm, Output};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::IndexSlice;
-use rustc_middle::mir::{create_dump_file, dump_enabled, dump_mir, PassWhere};
+use rustc_middle::mir::{
-use rustc_middle::mir::{Body, ClosureOutlivesSubject, ClosureRegionRequirements, Promoted};
+    create_dump_file, dump_enabled, dump_mir, Body, ClosureOutlivesSubject,
+    ClosureRegionRequirements, PassWhere, Promoted,
+};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, OpaqueHiddenType, TyCtxt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
@@ -13,25 +20,16 @@ use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_mir_dataflow::ResultsCursor;
 use rustc_span::symbol::sym;
-use std::env;
-use std::io;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::str::FromStr;
 
-use crate::{
+use crate::borrow_set::BorrowSet;
-    borrow_set::BorrowSet,
+use crate::consumers::ConsumerOptions;
-    consumers::ConsumerOptions,
+use crate::diagnostics::RegionErrors;
-    diagnostics::RegionErrors,
+use crate::facts::{AllFacts, AllFactsExt, RustcFacts};
-    facts::{AllFacts, AllFactsExt, RustcFacts},
+use crate::location::LocationTable;
-    location::LocationTable,
+use crate::region_infer::RegionInferenceContext;
-    polonius,
+use crate::type_check::{self, MirTypeckRegionConstraints, MirTypeckResults};
-    region_infer::RegionInferenceContext,
+use crate::universal_regions::UniversalRegions;
-    renumber,
+use crate::{polonius, renumber, BorrowckInferCtxt};
-    type_check::{self, MirTypeckRegionConstraints, MirTypeckResults},
-    universal_regions::UniversalRegions,
-    BorrowckInferCtxt,
-};
 
 pub type PoloniusOutput = Output<RustcFacts>;
 

compiler/rustc_borrowck/src/path_utils.rs

@@ -1,13 +1,11 @@
-use crate::borrow_set::{BorrowData, BorrowSet, TwoPhaseActivation};
-use crate::places_conflict;
-use crate::AccessDepth;
-use crate::BorrowIndex;
 use rustc_data_structures::graph::dominators::Dominators;
-use rustc_middle::mir::BorrowKind;
+use rustc_middle::mir::{BasicBlock, Body, BorrowKind, Location, Place, PlaceRef, ProjectionElem};
-use rustc_middle::mir::{BasicBlock, Body, Location, Place, PlaceRef, ProjectionElem};
 use rustc_middle::ty::TyCtxt;
 use rustc_target::abi::FieldIdx;
 
+use crate::borrow_set::{BorrowData, BorrowSet, TwoPhaseActivation};
+use crate::{places_conflict, AccessDepth, BorrowIndex};
+
 /// Returns `true` if the borrow represented by `kind` is
 /// allowed to be split into separate Reservation and
 /// Activation phases.

compiler/rustc_borrowck/src/place_ext.rs

@@ -1,10 +1,10 @@
-use crate::borrow_set::LocalsStateAtExit;
 use rustc_hir as hir;
 use rustc_macros::extension;
-use rustc_middle::mir::ProjectionElem;
+use rustc_middle::mir::{Body, Mutability, Place, ProjectionElem};
-use rustc_middle::mir::{Body, Mutability, Place};
 use rustc_middle::ty::{self, TyCtxt};
 
+use crate::borrow_set::LocalsStateAtExit;
+
 #[extension(pub trait PlaceExt<'tcx>)]
 impl<'tcx> Place<'tcx> {
     /// Returns `true` if we can safely ignore borrows of this place.

compiler/rustc_borrowck/src/places_conflict.rs

@@ -50,17 +50,17 @@
 //!    and either equal or disjoint.
 //!  - If we did run out of access, the borrow can access a part of it.
 
-use crate::ArtificialField;
+use std::cmp::max;
-use crate::Overlap;
+use std::iter;
-use crate::{AccessDepth, Deep, Shallow};
+
 use rustc_hir as hir;
 use rustc_middle::bug;
 use rustc_middle::mir::{
     Body, BorrowKind, FakeBorrowKind, MutBorrowKind, Place, PlaceElem, PlaceRef, ProjectionElem,
 };
 use rustc_middle::ty::{self, TyCtxt};
-use std::cmp::max;
+
-use std::iter;
+use crate::{AccessDepth, ArtificialField, Deep, Overlap, Shallow};
 
 /// When checking if a place conflicts with another place, this enum is used to influence decisions
 /// where a place might be equal or disjoint with another place, such as if `a[i] == a[j]`.

compiler/rustc_borrowck/src/polonius/loan_invalidations.rs

@@ -2,17 +2,19 @@ use rustc_data_structures::graph::dominators::Dominators;
 use rustc_middle::bug;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{
-    self, BasicBlock, Body, FakeBorrowKind, Location, NonDivergingIntrinsic, Place, Rvalue,
+    self, BasicBlock, Body, BorrowKind, FakeBorrowKind, InlineAsmOperand, Location, Mutability,
+    NonDivergingIntrinsic, Operand, Place, Rvalue, Statement, StatementKind, Terminator,
+    TerminatorKind,
 };
-use rustc_middle::mir::{BorrowKind, Mutability, Operand};
-use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};
-use rustc_middle::mir::{Statement, StatementKind};
 use rustc_middle::ty::TyCtxt;
 
+use crate::borrow_set::BorrowSet;
+use crate::facts::AllFacts;
+use crate::location::LocationTable;
+use crate::path_utils::*;
 use crate::{
-    borrow_set::BorrowSet, facts::AllFacts, location::LocationTable, path_utils::*, AccessDepth,
+    AccessDepth, Activation, ArtificialField, BorrowIndex, Deep, LocalMutationIsAllowed, Read,
-    Activation, ArtificialField, BorrowIndex, Deep, LocalMutationIsAllowed, Read, ReadKind,
+    ReadKind, ReadOrWrite, Reservation, Shallow, Write, WriteKind,
-    ReadOrWrite, Reservation, Shallow, Write, WriteKind,
 };
 
 /// Emit `loan_invalidated_at` facts.

compiler/rustc_borrowck/src/polonius/loan_kills.rs

@@ -5,7 +5,10 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::TyCtxt;
 
-use crate::{borrow_set::BorrowSet, facts::AllFacts, location::LocationTable, places_conflict};
+use crate::borrow_set::BorrowSet;
+use crate::facts::AllFacts;
+use crate::location::LocationTable;
+use crate::places_conflict;
 
 /// Emit `loan_killed_at` and `cfg_edge` facts at the same time.
 pub(super) fn emit_loan_kills<'tcx>(

compiler/rustc_borrowck/src/prefixes.rs

@@ -4,10 +4,10 @@
 //! is borrowed. But: writing `a` is legal if `*a` is borrowed,
 //! whether or not `a` is a shared or mutable reference. [...] "
 
-use super::MirBorrowckCtxt;
-
 use rustc_middle::mir::{PlaceRef, ProjectionElem};
 
+use super::MirBorrowckCtxt;
+
 pub trait IsPrefixOf<'tcx> {
     fn is_prefix_of(&self, other: PlaceRef<'tcx>) -> bool;
 }

compiler/rustc_borrowck/src/region_infer/dump_mir.rs

@@ -3,11 +3,13 @@
 //! state of region inference. This code handles emitting the region
 //! context internal state.
 
-use super::{OutlivesConstraint, RegionInferenceContext};
+use std::io::{self, Write};
-use crate::type_check::Locations;
+
 use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::ty::TyCtxt;
-use std::io::{self, Write};
+
+use super::{OutlivesConstraint, RegionInferenceContext};
+use crate::type_check::Locations;
 
 // Room for "'_#NNNNr" before things get misaligned.
 // Easy enough to fix if this ever doesn't seem like

compiler/rustc_borrowck/src/region_infer/graphviz.rs

@@ -5,11 +5,12 @@
 use std::borrow::Cow;
 use std::io::{self, Write};
 
-use super::*;
 use itertools::Itertools;
 use rustc_graphviz as dot;
 use rustc_middle::ty::UniverseIndex;
 
+use super::*;
+
 fn render_outlives_constraint(constraint: &OutlivesConstraint<'_>) -> String {
     match constraint.locations {
         Locations::All(_) => "All(...)".to_string(),

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -17,27 +17,25 @@ use rustc_middle::mir::{
     ClosureRegionRequirements, ConstraintCategory, Local, Location, ReturnConstraint,
     TerminatorKind,
 };
-use rustc_middle::traits::ObligationCause;
+use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
-use rustc_middle::traits::ObligationCauseCode;
 use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, UniverseIndex};
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_span::Span;
 
 use crate::constraints::graph::{self, NormalConstraintGraph, RegionGraph};
+use crate::constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet};
 use crate::dataflow::BorrowIndex;
-use crate::{
+use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};
-    constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet},
+use crate::member_constraints::{MemberConstraintSet, NllMemberConstraintIndex};
-    diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo},
+use crate::nll::PoloniusOutput;
-    member_constraints::{MemberConstraintSet, NllMemberConstraintIndex},
+use crate::region_infer::reverse_sccs::ReverseSccGraph;
-    nll::PoloniusOutput,
+use crate::region_infer::values::{
-    region_infer::reverse_sccs::ReverseSccGraph,
-    region_infer::values::{
     LivenessValues, PlaceholderIndices, RegionElement, RegionValues, ToElementIndex,
-    },
-    type_check::{free_region_relations::UniversalRegionRelations, Locations},
-    universal_regions::UniversalRegions,
-    BorrowckInferCtxt,
 };
+use crate::type_check::free_region_relations::UniversalRegionRelations;
+use crate::type_check::Locations;
+use crate::universal_regions::UniversalRegions;
+use crate::BorrowckInferCtxt;
 
 mod dump_mir;
 mod graphviz;

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -3,22 +3,20 @@ use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::OpaqueTyOrigin;
-use rustc_infer::infer::TyCtxtInferExt as _;
+use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, TyCtxtInferExt as _};
-use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_macros::extension;
 use rustc_middle::ty::visit::TypeVisitableExt;
-use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{
-use rustc_middle::ty::{GenericArgKind, GenericArgs};
+    self, GenericArgKind, GenericArgs, OpaqueHiddenType, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable,
+};
 use rustc_span::Span;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::ObligationCtxt;
 
-use crate::session_diagnostics::LifetimeMismatchOpaqueParam;
-use crate::session_diagnostics::NonGenericOpaqueTypeParam;
-use crate::universal_regions::RegionClassification;
-
 use super::RegionInferenceContext;
+use crate::session_diagnostics::{LifetimeMismatchOpaqueParam, NonGenericOpaqueTypeParam};
+use crate::universal_regions::RegionClassification;
 
 impl<'tcx> RegionInferenceContext<'tcx> {
     /// Resolve any opaque types that were encountered while borrow checking

compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs

@@ -1,10 +1,12 @@
-use crate::constraints::ConstraintSccIndex;
+use std::ops::Range;
-use crate::RegionInferenceContext;
+
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::graph;
 use rustc_data_structures::graph::vec_graph::VecGraph;
 use rustc_middle::ty::RegionVid;
-use std::ops::Range;
+
+use crate::constraints::ConstraintSccIndex;
+use crate::RegionInferenceContext;
 
 pub(crate) struct ReverseSccGraph {
     graph: VecGraph<ConstraintSccIndex>,

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -1,14 +1,13 @@
-use rustc_data_structures::fx::FxHashSet;
+use std::fmt::Debug;
-use rustc_data_structures::fx::FxIndexSet;
+use std::rc::Rc;
+
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_index::bit_set::SparseBitMatrix;
-use rustc_index::interval::IntervalSet;
+use rustc_index::interval::{IntervalSet, SparseIntervalMatrix};
-use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::Idx;
 use rustc_middle::mir::{BasicBlock, Location};
 use rustc_middle::ty::{self, RegionVid};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
-use std::fmt::Debug;
-use std::rc::Rc;
 
 use crate::BorrowIndex;
 

compiler/rustc_borrowck/src/renumber.rs

@@ -1,12 +1,12 @@
-use crate::BorrowckInferCtxt;
 use rustc_index::IndexSlice;
 use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::mir::visit::{MutVisitor, TyContext};
 use rustc_middle::mir::{Body, ConstOperand, Location, Promoted};
-use rustc_middle::ty::GenericArgsRef;
+use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypeFoldable};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_span::Symbol;
 
+use crate::BorrowckInferCtxt;
+
 /// Replaces all free regions appearing in the MIR with fresh
 /// inference variables, returning the number of variables created.
 #[instrument(skip(infcx, body, promoted), level = "debug")]

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -1,4 +1,5 @@
-use rustc_errors::{codes::*, MultiSpan};
+use rustc_errors::codes::*;
+use rustc_errors::MultiSpan;
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::{GenericArg, Ty};
 use rustc_span::Span;

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -10,9 +10,8 @@ use rustc_span::Span;
 use rustc_trait_selection::traits::query::type_op::{self, TypeOpOutput};
 use rustc_trait_selection::traits::ObligationCause;
 
-use crate::diagnostics::ToUniverseInfo;
-
 use super::{Locations, NormalizeLocation, TypeChecker};
+use crate::diagnostics::ToUniverseInfo;
 
 impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     /// Given some operation `op` that manipulates types, proves

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -14,12 +14,10 @@ use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
 use rustc_trait_selection::traits::ScrubbedTraitError;
 
-use crate::{
+use crate::constraints::OutlivesConstraint;
-    constraints::OutlivesConstraint,
+use crate::region_infer::TypeTest;
-    region_infer::TypeTest,
+use crate::type_check::{Locations, MirTypeckRegionConstraints};
-    type_check::{Locations, MirTypeckRegionConstraints},
+use crate::universal_regions::UniversalRegions;
-    universal_regions::UniversalRegions,
-};
 
 pub(crate) struct ConstraintConversion<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -1,11 +1,12 @@
+use std::rc::Rc;
+
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::transitive_relation::{TransitiveRelation, TransitiveRelationBuilder};
 use rustc_hir::def::DefKind;
 use rustc_infer::infer::canonical::QueryRegionConstraints;
-use rustc_infer::infer::outlives;
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::region_constraints::GenericKind;
-use rustc_infer::infer::InferCtxt;
+use rustc_infer::infer::{outlives, InferCtxt};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::query::OutlivesBound;
 use rustc_middle::traits::ObligationCause;
@@ -14,14 +15,10 @@ use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::solve::deeply_normalize;
 use rustc_trait_selection::traits::query::type_op::{self, TypeOp};
-use std::rc::Rc;
 use type_op::TypeOpOutput;
 
-use crate::{
+use crate::type_check::{constraint_conversion, Locations, MirTypeckRegionConstraints};
-    type_check::constraint_conversion,
+use crate::universal_regions::UniversalRegions;
-    type_check::{Locations, MirTypeckRegionConstraints},
-    universal_regions::UniversalRegions,
-};
 
 #[derive(Debug)]
 pub(crate) struct UniversalRegionRelations<'tcx> {

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -16,11 +16,10 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
 
+use super::{Locations, TypeChecker};
 use crate::renumber::RegionCtxt;
 use crate::universal_regions::{DefiningTy, UniversalRegions};
 
-use super::{Locations, TypeChecker};
-
 impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     /// Check explicit closure signature annotation,
     /// e.g., `|x: FxIndexMap<_, &'static u32>| ...`.

compiler/rustc_borrowck/src/type_check/liveness/mod.rs

@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
 use itertools::{Either, Itertools};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::mir::visit::{TyContext, Visitor};
@@ -9,14 +11,11 @@ use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_mir_dataflow::ResultsCursor;
-use std::rc::Rc;
-
-use crate::{
-    constraints::OutlivesConstraintSet, region_infer::values::LivenessValues,
-    universal_regions::UniversalRegions,
-};
 
 use super::TypeChecker;
+use crate::constraints::OutlivesConstraintSet;
+use crate::region_infer::values::LivenessValues;
+use crate::universal_regions::UniversalRegions;
 
 mod local_use_map;
 mod polonius;

compiler/rustc_borrowck/src/type_check/liveness/polonius.rs

@@ -1,11 +1,11 @@
-use crate::def_use::{self, DefUse};
-use crate::location::{LocationIndex, LocationTable};
 use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::{Body, Local, Location, Place};
 use rustc_middle::ty::GenericArg;
 use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
 
 use super::TypeChecker;
+use crate::def_use::{self, DefUse};
+use crate::location::{LocationIndex, LocationTable};
 
 type VarPointRelation = Vec<(Local, LocationIndex)>;
 type PathPointRelation = Vec<(MovePathIndex, LocationIndex)>;

compiler/rustc_borrowck/src/type_check/liveness/trace.rs

@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_index::bit_set::BitSet;
 use rustc_index::interval::IntervalSet;
@@ -6,24 +8,19 @@ use rustc_infer::infer::outlives::for_liveness;
 use rustc_middle::mir::{BasicBlock, Body, ConstraintCategory, Local, Location};
 use rustc_middle::traits::query::DropckOutlivesResult;
 use rustc_middle::ty::{Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
+use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
+use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
+use rustc_mir_dataflow::ResultsCursor;
 use rustc_span::DUMMY_SP;
 use rustc_trait_selection::traits::query::type_op::outlives::DropckOutlives;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
-use std::rc::Rc;
-
-use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
-use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
-use rustc_mir_dataflow::ResultsCursor;
 
 use crate::location::RichLocation;
-use crate::{
+use crate::region_infer::values::{self, LiveLoans};
-    region_infer::values::{self, LiveLoans},
+use crate::type_check::liveness::local_use_map::LocalUseMap;
-    type_check::liveness::local_use_map::LocalUseMap,
+use crate::type_check::liveness::polonius;
-    type_check::liveness::polonius,
+use crate::type_check::{NormalizeLocation, TypeChecker};
-    type_check::NormalizeLocation,
-    type_check::TypeChecker,
-};
 
 /// This is the heart of the liveness computation. For each variable X
 /// that requires a liveness computation, it walks over all the uses

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -4,7 +4,6 @@ use std::rc::Rc;
 use std::{fmt, iter, mem};
 
 use either::Either;
-
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::ErrorGuaranteed;
@@ -28,44 +27,38 @@ use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::visit::TypeVisitableExt;
 use rustc_middle::ty::{
     self, Binder, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, CoroutineArgsExt,
-    Dynamic, OpaqueHiddenType, OpaqueTypeKey, RegionVid, Ty, TyCtxt, UserType,
+    Dynamic, GenericArgsRef, OpaqueHiddenType, OpaqueTypeKey, RegionVid, Ty, TyCtxt, UserArgs,
-    UserTypeAnnotationIndex,
+    UserType, UserTypeAnnotationIndex,
 };
-use rustc_middle::ty::{GenericArgsRef, UserArgs};
 use rustc_middle::{bug, span_bug};
+use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
+use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
+use rustc_mir_dataflow::ResultsCursor;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
-use rustc_span::DUMMY_SP;
 use rustc_target::abi::{FieldIdx, FIRST_VARIANT};
-use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
+use rustc_trait_selection::traits::query::type_op::custom::{
-use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
+    scrape_region_constraints, CustomTypeOp,
+};
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
-
 use rustc_trait_selection::traits::PredicateObligation;
 
-use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
+use crate::borrow_set::BorrowSet;
-use rustc_mir_dataflow::move_paths::MoveData;
+use crate::constraints::{OutlivesConstraint, OutlivesConstraintSet};
-use rustc_mir_dataflow::ResultsCursor;
+use crate::diagnostics::UniverseInfo;
-
+use crate::facts::AllFacts;
+use crate::location::LocationTable;
+use crate::member_constraints::MemberConstraintSet;
+use crate::region_infer::values::{LivenessValues, PlaceholderIndex, PlaceholderIndices};
+use crate::region_infer::TypeTest;
 use crate::renumber::RegionCtxt;
 use crate::session_diagnostics::{MoveUnsized, SimdIntrinsicArgConst};
-use crate::{
+use crate::type_check::free_region_relations::{CreateResult, UniversalRegionRelations};
-    borrow_set::BorrowSet,
+use crate::universal_regions::{DefiningTy, UniversalRegions};
-    constraints::{OutlivesConstraint, OutlivesConstraintSet},
+use crate::{path_utils, BorrowckInferCtxt};
-    diagnostics::UniverseInfo,
-    facts::AllFacts,
-    location::LocationTable,
-    member_constraints::MemberConstraintSet,
-    path_utils,
-    region_infer::values::{LivenessValues, PlaceholderIndex, PlaceholderIndices},
-    region_infer::TypeTest,
-    type_check::free_region_relations::{CreateResult, UniversalRegionRelations},
-    universal_regions::{DefiningTy, UniversalRegions},
-    BorrowckInferCtxt,
-};
 
 macro_rules! span_mirbug {
     ($context:expr, $elem:expr, $($message:tt)*) => ({

compiler/rustc_borrowck/src/universal_regions.rs

@@ -15,6 +15,9 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
+use std::cell::Cell;
+use std::iter;
+
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Diag;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -25,13 +28,12 @@ use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_macros::extension;
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, InlineConstArgs, InlineConstArgsParts, RegionVid, Ty, TyCtxt};
+use rustc_middle::ty::{
-use rustc_middle::ty::{GenericArgs, GenericArgsRef};
+    self, GenericArgs, GenericArgsRef, InlineConstArgs, InlineConstArgsParts, RegionVid, Ty, TyCtxt,
+};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{ErrorGuaranteed, Symbol};
-use std::cell::Cell;
-use std::iter;
 
 use crate::renumber::RegionCtxt;
 use crate::BorrowckInferCtxt;

compiler/rustc_borrowck/src/util/collect_writes.rs

@@ -1,5 +1,4 @@
-use rustc_middle::mir::visit::PlaceContext;
+use rustc_middle::mir::visit::{PlaceContext, Visitor};
-use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{Body, Local, Location};
 
 pub trait FindAssignments {

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -1,14 +1,15 @@
-use crate::errors;
-use crate::util::check_builtin_macro_attribute;
-
 use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, FnHeader, FnSig, Generics, StmtKind};
+use rustc_ast::{
-use rustc_ast::{Fn, ItemKind, Safety, Stmt, TyKind};
+    self as ast, Fn, FnHeader, FnSig, Generics, ItemKind, Safety, Stmt, StmtKind, TyKind,
+};
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::Span;
 use thin_vec::{thin_vec, ThinVec};
 
+use crate::errors;
+use crate::util::check_builtin_macro_attribute;
+
 pub(crate) fn expand(
     ecx: &mut ExtCtxt<'_>,
     _span: Span,

compiler/rustc_builtin_macros/src/asm.rs

@@ -1,8 +1,5 @@
-use crate::errors;
-use crate::util::expr_to_spanned_string;
 use ast::token::IdentIsRaw;
 use lint::BuiltinLintDiag;
-use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter};
 use rustc_ast::tokenstream::TokenStream;
@@ -11,13 +8,15 @@ use rustc_errors::PResult;
 use rustc_expand::base::*;
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_parse::parser::Parser;
-use rustc_parse_format as parse;
 use rustc_session::lint;
-use rustc_span::symbol::Ident;
+use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{ErrorGuaranteed, InnerSpan, Span};
 use rustc_target::asm::InlineAsmArch;
 use smallvec::smallvec;
+use {rustc_ast as ast, rustc_parse_format as parse};
+
+use crate::errors;
+use crate::util::expr_to_spanned_string;
 
 pub struct AsmArgs {
     pub templates: Vec<P<ast::Expr>>,

compiler/rustc_builtin_macros/src/assert.rs

@@ -1,12 +1,9 @@
 mod context;
 
-use crate::edition_panic::use_panic_2021;
-use crate::errors;
 use rustc_ast::ptr::P;
-use rustc_ast::token;
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
-use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp};
+use rustc_ast::{token, DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp};
 use rustc_ast_pretty::pprust;
 use rustc_errors::PResult;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
@@ -15,6 +12,9 @@ use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
 use thin_vec::thin_vec;
 
+use crate::edition_panic::use_panic_2021;
+use crate::errors;
+
 pub(crate) fn expand_assert<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
     span: Span,

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -1,17 +1,15 @@
+use rustc_ast::ptr::P;
+use rustc_ast::token::{self, Delimiter, IdentIsRaw};
+use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::{
-    ptr::P,
-    token::{self, Delimiter, IdentIsRaw},
-    tokenstream::{DelimSpan, TokenStream, TokenTree},
     BinOpKind, BorrowKind, DelimArgs, Expr, ExprKind, ItemKind, MacCall, MethodCall, Mutability,
     Path, PathSegment, Stmt, StructRest, UnOp, UseTree, UseTreeKind, DUMMY_NODE_ID,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_expand::base::ExtCtxt;
-use rustc_span::{
+use rustc_span::symbol::{sym, Ident, Symbol};
-    symbol::{sym, Ident, Symbol},
+use rustc_span::Span;
-    Span,
-};
 use thin_vec::{thin_vec, ThinVec};
 
 pub(super) struct Context<'cx, 'a> {

compiler/rustc_builtin_macros/src/cfg.rs

@@ -2,14 +2,14 @@
 //! a literal `true` or `false` based on whether the given cfg matches the
 //! current compilation environment.
 
-use crate::errors;
-use rustc_ast as ast;
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
-use rustc_attr as attr;
 use rustc_errors::PResult;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_span::Span;
+use {rustc_ast as ast, rustc_attr as attr};
+
+use crate::errors;
 
 pub(crate) fn expand_cfg(
     cx: &mut ExtCtxt<'_>,

compiler/rustc_builtin_macros/src/cfg_accessible.rs

@@ -1,6 +1,5 @@
 //! Implementation of the `#[cfg_accessible(path)]` attribute macro.
 
-use crate::errors;
 use rustc_ast as ast;
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, Indeterminate, MultiItemModifier};
 use rustc_feature::AttributeTemplate;
@@ -8,6 +7,8 @@ use rustc_parse::validate_attr;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
+use crate::errors;
+
 pub(crate) struct Expander;
 
 fn validate_input<'a>(ecx: &ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'a ast::Path> {

compiler/rustc_builtin_macros/src/cfg_eval.rs

@@ -1,13 +1,10 @@
-use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
-
 use core::ops::ControlFlow;
+
 use rustc_ast as ast;
 use rustc_ast::mut_visit::MutVisitor;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{AssocCtxt, Visitor};
-use rustc_ast::NodeId;
+use rustc_ast::{mut_visit, visit, Attribute, HasAttrs, HasTokens, NodeId};
-use rustc_ast::{mut_visit, visit};
-use rustc_ast::{Attribute, HasAttrs, HasTokens};
 use rustc_errors::PResult;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_expand::config::StripUnconfigured;
@@ -20,6 +17,8 @@ use rustc_span::Span;
 use smallvec::SmallVec;
 use tracing::instrument;
 
+use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
+
 pub(crate) fn expand(
     ecx: &mut ExtCtxt<'_>,
     _span: Span,

compiler/rustc_builtin_macros/src/cmdline_attrs.rs

@@ -1,14 +1,14 @@
 //! Attributes injected into the crate root from command line using `-Z crate-attr`.
 
-use crate::errors;
 use rustc_ast::attr::mk_attr;
-use rustc_ast::token;
+use rustc_ast::{self as ast, token, AttrItem, AttrStyle};
-use rustc_ast::{self as ast, AttrItem, AttrStyle};
 use rustc_parse::parser::ForceCollect;
 use rustc_parse::{new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_session::parse::ParseSess;
 use rustc_span::FileName;
 
+use crate::errors;
+
 pub fn inject(krate: &mut ast::Crate, psess: &ParseSess, attrs: &[String]) {
     for raw_attr in attrs {
         let mut parser = unwrap_or_emit_fatal(new_parser_from_source_str(

compiler/rustc_builtin_macros/src/compile_error.rs

@@ -1,10 +1,11 @@
 // The compiler code necessary to support the compile_error! extension.
 
-use crate::util::get_single_str_from_tts;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
 use rustc_span::Span;
 
+use crate::util::get_single_str_from_tts;
+
 pub(crate) fn expand_compile_error<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
     sp: Span,