Remove unused imports

Author: Veykril

crates/hir-def/src/expr_store.rs

@@ -18,23 +18,19 @@ use la_arena::{Arena, ArenaMap};
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
 use span::{Edition, MacroFileId, SyntaxContext};
-use syntax::{
-    AstPtr, SyntaxNodePtr,
-    ast::{self, HasGenericParams},
-};
+use syntax::{AstPtr, SyntaxNodePtr, ast};
 use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    BlockId, GenericDefId, SyntheticSyntax,
+    BlockId, SyntheticSyntax,
     db::DefDatabase,
     expr_store::path::Path,
     hir::{
         Array, AsmOperand, Binding, BindingId, Expr, ExprId, ExprOrPatId, Label, LabelId, Pat,
         PatId, RecordFieldPat, Statement,
     },
     nameres::DefMap,
-    src::HasSource,
     type_ref::{PathId, TypeRef, TypeRefId},
 };
 

crates/hir-def/src/expr_store/body.rs

@@ -3,7 +3,6 @@
 use std::ops;
 
 use hir_expand::{InFile, Lookup};
-use la_arena::{Idx, RawIdx};
 use span::Edition;
 use syntax::ast;
 use triomphe::Arc;
@@ -12,11 +11,9 @@ use crate::{
     DefWithBodyId, HasModule,
     db::DefDatabase,
     expr_store::{
-        ExpressionStore, ExpressionStoreSourceMap, SelfParamPtr, expander::Expander,
-        lower::lower_body, pretty,
+        ExpressionStore, ExpressionStoreSourceMap, SelfParamPtr, lower::lower_body, pretty,
     },
     hir::{BindingId, ExprId, PatId},
-    item_tree::AttrOwner,
     src::HasSource,
 };
 

crates/hir-def/src/expr_store/expander.rs

@@ -1,23 +1,20 @@
 //! Macro expansion utilities.
 
-use std::cell::OnceCell;
 use std::mem;
 
 use base_db::Crate;
-use cfg::CfgOptions;
 use drop_bomb::DropBomb;
 use hir_expand::eager::EagerCallBackFn;
 use hir_expand::{
     ExpandError, ExpandErrorKind, ExpandResult, HirFileId, InFile, Lookup, MacroCallId,
-    attrs::RawAttrs, mod_path::ModPath, span_map::SpanMap,
+    mod_path::ModPath, span_map::SpanMap,
 };
 use span::{AstIdMap, Edition, SyntaxContext};
-use syntax::{AstPtr, Parse, ast};
+use syntax::{Parse, ast};
 use triomphe::Arc;
 
-use crate::expr_store::path::Path;
 use crate::nameres::DefMap;
-use crate::{AsMacroCall, MacroId, ModuleId, UnresolvedMacro, attr::Attrs, db::DefDatabase};
+use crate::{AsMacroCall, MacroId, UnresolvedMacro, db::DefDatabase};
 
 #[derive(Debug)]
 pub(super) struct Expander {

crates/hir-def/src/expr_store/lower.rs

@@ -5,37 +5,35 @@ mod asm;
 mod generics;
 mod path;
 
-use std::{cell::OnceCell, mem};
+use std::mem;
 
-use base_db::Crate;
 use either::Either;
 use hir_expand::{
-    AstId, InFile, Lookup, MacroDefId,
+    InFile, Lookup, MacroDefId,
     attrs::RawAttrs,
     mod_path::tool_path,
     name::{AsName, Name},
-    span_map::{ExpansionSpanMap, SpanMap},
+    span_map::SpanMap,
 };
 use intern::{Symbol, sym};
 use rustc_hash::FxHashMap;
-use span::{AstIdMap, AstIdNode, Edition, EditionedFileId, FileId, HirFileId, RealSpanMap};
+use span::HirFileId;
 use stdx::never;
 use syntax::{
     AstNode, AstPtr, AstToken as _, SyntaxNodePtr,
     ast::{
         self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasGenericArgs,
         HasGenericParams, HasLoopBody, HasName, HasTypeBounds, IsString, RangeItem,
-        SlicePatComponents, make::impl_,
+        SlicePatComponents,
     },
 };
 use text_size::TextSize;
 use thin_vec::ThinVec;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, BlockId, BlockLoc, ConstBlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId,
-    ItemTreeLoc, MacroId, ModuleDefId, ModuleId, StructId, TraitAliasId, TraitId, TypeAliasId,
-    UnresolvedMacro,
+    AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, ItemTreeLoc,
+    MacroId, ModuleDefId, ModuleId, TraitAliasId, TraitId, TypeAliasId, UnresolvedMacro,
     attr::Attrs,
     builtin_type::BuiltinUint,
     db::DefDatabase,
@@ -60,8 +58,6 @@ use crate::{
     item_tree::FieldsShape,
     lang_item::LangItem,
     nameres::{DefMap, LocalDefMap, MacroSubNs},
-    signatures::StructSignature,
-    src::HasSource,
     type_ref::{
         ArrayType, ConstRef, FnType, LifetimeRef, Mutability, PathId, Rawness, RefType,
         TraitBoundModifier, TraitRef, TypeBound, TypeRef, TypeRefId, UseArgRef,

crates/hir-def/src/expr_store/lower/generics.rs

@@ -3,36 +3,28 @@
 //! generic parameters. See also the `Generics` type and the `generics_of` query
 //! in rustc.
 
-use std::{ops, sync::LazyLock};
+use std::sync::LazyLock;
 
 use either::Either;
 use hir_expand::{
-    ExpandResult,
     attrs::RawAttrs,
     name::{AsName, Name},
 };
 use intern::sym;
-use la_arena::{Arena, RawIdx};
-use stdx::impl_from;
-use syntax::ast::{self, HasGenericParams, HasName, HasTypeBounds};
+use la_arena::Arena;
+use syntax::ast::{self, HasName, HasTypeBounds};
 use thin_vec::ThinVec;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, ConstParamId, GenericDefId, HasModule, ItemTreeLoc, LifetimeParamId,
-    LocalLifetimeParamId, LocalTypeOrConstParamId, Lookup, TypeOrConstParamId, TypeParamId,
+    GenericDefId, TypeOrConstParamId, TypeParamId,
     attr::Attrs,
-    db::DefDatabase,
     expr_store::lower::ExprCollector,
     hir::generics::{
         ConstParamData, GenericParams, LifetimeParamData, TypeOrConstParamData, TypeParamData,
         TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,
     },
-    item_tree::{AttrOwner, FileItemTreeId, ItemTree},
-    nameres::{DefMap, LocalDefMap, MacroSubNs},
-    type_ref::{
-        ArrayType, ConstRef, FnType, LifetimeRef, PathId, RefType, TypeBound, TypeRef, TypeRefId,
-    },
+    type_ref::{LifetimeRef, TypeBound, TypeRef, TypeRefId},
 };
 
 pub(crate) struct GenericParamsCollector<'db, 'c> {

crates/hir-def/src/expr_store/lower/path.rs

@@ -5,10 +5,7 @@ mod tests;
 
 use std::iter;
 
-use crate::{
-    expr_store::{lower::ExprCollector, path::NormalPath},
-    type_ref::ConstRef,
-};
+use crate::expr_store::{lower::ExprCollector, path::NormalPath};
 
 use hir_expand::{
     mod_path::{ModPath, PathKind, resolve_crate_root},
@@ -17,15 +14,13 @@ use hir_expand::{
 use intern::{Interned, sym};
 use syntax::{
     AstPtr,
-    ast::{self, AstNode, HasGenericArgs, HasTypeBounds},
+    ast::{self, AstNode, HasGenericArgs},
 };
 use thin_vec::ThinVec;
 
 use crate::{
-    expr_store::path::{
-        AssociatedTypeBinding, GenericArg, GenericArgs, GenericArgsParentheses, Path,
-    },
-    type_ref::{LifetimeRef, TypeBound, TypeRef},
+    expr_store::path::{GenericArg, GenericArgs, Path},
+    type_ref::{TypeBound, TypeRef},
 };
 
 #[cfg(test)]

crates/hir-def/src/expr_store/path.rs

@@ -1,23 +1,16 @@
 //! A desugared representation of paths like `crate::foo` or `<Type as Trait>::bar`.
 
-use std::{
-    fmt::{self, Display},
-    iter,
-};
+use std::iter;
 
 use crate::{
-    hir::ExprId,
     lang_item::LangItemTarget,
     type_ref::{ConstRef, LifetimeRef, TypeBound, TypeRefId},
 };
 use hir_expand::{
-    Intern,
     mod_path::{ModPath, PathKind},
     name::Name,
 };
 use intern::Interned;
-use span::Edition;
-use syntax::ast;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Path {

crates/hir-def/src/expr_store/pretty.rs

@@ -1,4 +1,5 @@
 //! A pretty-printer for HIR.
+#![allow(dead_code)]
 
 use std::{
     fmt::{self, Write},
@@ -10,15 +11,14 @@ use itertools::Itertools;
 use span::Edition;
 
 use crate::{
-    DefWithBodyId, ItemTreeLoc, TypeOrConstParamId, TypeParamId,
+    DefWithBodyId, ItemTreeLoc, TypeParamId,
     expr_store::path::{GenericArg, GenericArgs},
     hir::{
         Array, BindingAnnotation, CaptureBy, ClosureKind, Literal, Movability, Statement,
         generics::{GenericParams, WherePredicate, WherePredicateTypeTarget},
     },
-    item_tree::FieldsShape,
     lang_item::LangItemTarget,
-    signatures::{FunctionSignature, StructSignature},
+    signatures::{FnFlags, FunctionSignature, StructSignature},
     type_ref::{ConstRef, Mutability, TraitBoundModifier, TypeBound, UseArgRef},
 };
 
@@ -113,7 +113,6 @@ pub(crate) fn print_body_hir(
     p.buf
 }
 
-#[cfg(test)]
 pub(crate) fn print_path(
     db: &dyn DefDatabase,
     store: &ExpressionStore,
@@ -132,12 +131,12 @@ pub(crate) fn print_path(
     p.buf
 }
 
-#[cfg(test)]
 pub(crate) fn print_struct(
     db: &dyn DefDatabase,
     StructSignature { name, generic_params, store, flags, shape, repr }: &StructSignature,
     edition: Edition,
 ) -> String {
+    use crate::item_tree::FieldsShape;
     use crate::signatures::StructFlags;
 
     let mut p = Printer {
@@ -182,7 +181,6 @@ pub(crate) fn print_struct(
     p.buf
 }
 
-#[cfg(test)]
 pub(crate) fn print_function(
     db: &dyn DefDatabase,
     FunctionSignature {
@@ -197,8 +195,6 @@ pub(crate) fn print_function(
     }: &FunctionSignature,
     edition: Edition,
 ) -> String {
-    use crate::signatures::FnFlags;
-
     let mut p = Printer {
         db,
         store,
@@ -247,7 +243,6 @@ pub(crate) fn print_function(
     p.buf
 }
 
-#[cfg(test)]
 fn print_where_clauses(db: &dyn DefDatabase, generic_params: &GenericParams, p: &mut Printer<'_>) {
     if !generic_params.where_predicates.is_empty() {
         w!(p, "\nwhere\n");
@@ -258,8 +253,8 @@ fn print_where_clauses(db: &dyn DefDatabase, generic_params: &GenericParams, p:
                 }
                 match pred {
                     WherePredicate::TypeBound { target, bound } => match target {
-                        WherePredicateTypeTarget::TypeRef(idx) => {
-                            p.print_type_ref(*idx);
+                        &WherePredicateTypeTarget::TypeRef(idx) => {
+                            p.print_type_ref(idx);
                             w!(p, ": ");
                             p.print_type_bounds(std::slice::from_ref(bound));
                         }
@@ -312,7 +307,6 @@ fn print_where_clauses(db: &dyn DefDatabase, generic_params: &GenericParams, p:
     }
 }
 
-#[cfg(test)]
 fn print_generic_params(db: &dyn DefDatabase, generic_params: &GenericParams, p: &mut Printer<'_>) {
     if !generic_params.is_empty() {
         w!(p, "<");

crates/hir-def/src/expr_store/tests/signatures.rs

@@ -1,11 +1,9 @@
 use crate::{
-    DefWithBodyId, ModuleDefId,
+    GenericDefId, ModuleDefId,
     expr_store::pretty::{print_function, print_struct},
-    hir::MatchArm,
     test_db::TestDB,
 };
 use expect_test::{Expect, expect};
-use la_arena::RawIdx;
 use test_fixture::WithFixture;
 
 use super::super::*;

crates/hir-def/src/find_path.rs

@@ -12,7 +12,7 @@ use intern::sym;
 use rustc_hash::FxHashSet;
 
 use crate::{
-    ImportPathConfig, ItemTreeLoc, ModuleDefId, ModuleId,
+    ImportPathConfig, ModuleDefId, ModuleId,
     db::DefDatabase,
     item_scope::ItemInNs,
     nameres::DefMap,

crates/hir-def/src/hir.rs

@@ -26,7 +26,7 @@ use syntax::ast;
 use type_ref::TypeRefId;
 
 use crate::{
-    BlockId, ConstBlockId,
+    BlockId,
     builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
     expr_store::path::{GenericArgs, Path},
     type_ref::{Mutability, Rawness},

crates/hir-def/src/hir/type_ref.rs

@@ -1,29 +1,22 @@
 //! HIR for references to types. Paths in these are not yet resolved. They can
 //! be directly created from an ast::TypeRef, without further queries.
 
-use core::fmt;
-use std::{fmt::Write, ops::Index};
+use std::fmt::Write;
 
-use hir_expand::{
-    AstId, InFile,
-    db::ExpandDatabase,
-    name::{AsName, Name},
-};
-use intern::{Symbol, sym};
-use la_arena::{Arena, ArenaMap, Idx};
-use rustc_hash::FxHashMap;
-use span::Edition;
-use syntax::{AstPtr, ast};
+use hir_expand::name::Name;
+use intern::Symbol;
+use la_arena::Idx;
+use syntax::ast;
 use thin_vec::ThinVec;
 
 use crate::{
-    SyntheticSyntax, TypeParamId,
+    TypeParamId,
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
     expr_store::{
         ExpressionStore,
         path::{GenericArg, Path},
     },
-    hir::{ExprId, Literal, generics::LocalTypeOrConstParamId},
+    hir::{ExprId, Literal},
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]