Auto merge of rust-lang#14517 - Veykril:hir-def-refac, r=Veykril

internal: Shuffle around some hir_def modules

Author: bors

crates/hir-def/src/attr.rs

@@ -1,5 +1,7 @@
 //! A higher level attributes based on TokenTree, with also some shortcuts.
 
+pub mod builtin;
+
 #[cfg(test)]
 mod tests;
 

crates/hir-def/src/builtin_attr.rs renamed to crates/hir-def/src/attr/builtin.rs

@@ -25,7 +25,7 @@ use syntax::{ast, AstPtr, SyntaxNode, SyntaxNodePtr};
 use crate::{
     attr::Attrs,
     db::DefDatabase,
-    expr::{
+    hir::{
         dummy_expr_id, Binding, BindingId, Expr, ExprId, Label, LabelId, Pat, PatId, RecordFieldPat,
     },
     item_scope::BuiltinShadowMode,

crates/hir-def/src/body.rs

@@ -26,12 +26,14 @@ use syntax::{
 };
 
 use crate::{
-    adt::StructKind,
-    body::{Body, BodySourceMap, Expander, ExprPtr, LabelPtr, LabelSource, PatPtr},
-    body::{BodyDiagnostic, ExprSource, PatSource},
+    body::{
+        Body, BodyDiagnostic, BodySourceMap, Expander, ExprPtr, ExprSource, LabelPtr, LabelSource,
+        PatPtr, PatSource,
+    },
     builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
+    data::adt::StructKind,
     db::DefDatabase,
-    expr::{
+    hir::{
         dummy_expr_id, Array, Binding, BindingAnnotation, BindingId, ClosureKind, Expr, ExprId,
         FloatTypeWrapper, Label, LabelId, Literal, MatchArm, Movability, Pat, PatId,
         RecordFieldPat, RecordLitField, Statement,

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

@@ -5,7 +5,7 @@ use std::fmt::{self, Write};
 use syntax::ast::HasName;
 
 use crate::{
-    expr::{Array, BindingAnnotation, BindingId, ClosureKind, Literal, Movability, Statement},
+    hir::{Array, BindingAnnotation, BindingId, ClosureKind, Literal, Movability, Statement},
     pretty::{print_generic_args, print_path, print_type_ref},
     type_ref::TypeRef,
 };

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

@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use crate::{
     body::Body,
     db::DefDatabase,
-    expr::{Binding, BindingId, Expr, ExprId, LabelId, Pat, PatId, Statement},
+    hir::{Binding, BindingId, Expr, ExprId, LabelId, Pat, PatId, Statement},
     BlockId, DefWithBodyId,
 };
 

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

@@ -10,9 +10,8 @@ use syntax::ast::HasDocComments;
 
 use crate::{
     db::DefDatabase,
-    dyn_map::DynMap,
+    dyn_map::{keys, DynMap},
     item_scope::ItemScope,
-    keys,
     src::{HasChildSource, HasSource},
     AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, FieldId, ImplId, Lookup, MacroId,
     ModuleDefId, ModuleId, TraitId, VariantId,

crates/hir-def/src/child_by_source.rs

@@ -1,5 +1,7 @@
 //! Contains basic data about various HIR declarations.
 
+pub mod adt;
+
 use std::sync::Arc;
 
 use hir_expand::{name::Name, AstId, ExpandResult, HirFileId, InFile, MacroCallId, MacroDefKind};

crates/hir-def/src/data.rs

@@ -9,10 +9,10 @@ use la_arena::ArenaMap;
 use syntax::{ast, AstPtr};
 
 use crate::{
-    adt::{EnumData, StructData},
     attr::{Attrs, AttrsWithOwner},
     body::{scope::ExprScopes, Body, BodySourceMap},
     data::{
+        adt::{EnumData, StructData},
         ConstData, FunctionData, ImplData, Macro2Data, MacroRulesData, ProcMacroData, StaticData,
         TraitAliasData, TraitData, TypeAliasData,
     },

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

@@ -21,6 +21,8 @@
 //!
 //! This is a work of fiction. Any similarities to Kotlin's `BindingContext` are
 //! a coincidence.
+pub mod keys;
+
 use std::{
     hash::Hash,
     marker::PhantomData,

crates/hir-def/src/db.rs

@@ -20,8 +20,7 @@ use crate::{
     body::{Expander, LowerCtx},
     child_by_source::ChildBySource,
     db::DefDatabase,
-    dyn_map::DynMap,
-    keys,
+    dyn_map::{keys, DynMap},
     src::{HasChildSource, HasSource},
     type_ref::{LifetimeRef, TypeBound, TypeRef},
     AdtId, ConstParamId, GenericDefId, HasModule, LifetimeParamId, LocalLifetimeParamId,

crates/hir-def/src/dyn_map.rs

@@ -12,6 +12,8 @@
 //!
 //! See also a neighboring `body` module.
 
+pub mod type_ref;
+
 use std::fmt;
 
 use hir_expand::name::Name;
@@ -28,10 +30,10 @@ use crate::{
 
 pub use syntax::ast::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp};
 
-pub type ExprId = Idx<Expr>;
-
 pub type BindingId = Idx<Binding>;
 
+pub type ExprId = Idx<Expr>;
+
 /// FIXME: this is a hacky function which should be removed
 pub(crate) fn dummy_expr_id() -> ExprId {
     ExprId::from_raw(RawIdx::from(u32::MAX))

crates/hir-def/src/keys.rs renamed to crates/hir-def/src/dyn_map/keys.rs

@@ -13,7 +13,7 @@ use syntax::ast::{self, HasName};
 use crate::{
     body::LowerCtx,
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
-    expr::Literal,
+    hir::Literal,
     path::Path,
 };
 

crates/hir-def/src/generics.rs

@@ -18,24 +18,21 @@ pub mod db;
 
 pub mod attr;
 pub mod path;
-pub mod type_ref;
 pub mod builtin_type;
-pub mod builtin_attr;
 pub mod per_ns;
 pub mod item_scope;
 
 pub mod dyn_map;
-pub mod keys;
 
 pub mod item_tree;
 
-pub mod adt;
 pub mod data;
 pub mod generics;
 pub mod lang_item;
 pub mod layout;
 
-pub mod expr;
+pub mod hir;
+pub use self::hir::type_ref;
 pub mod body;
 pub mod resolver;
 
@@ -82,8 +79,8 @@ use syntax::ast;
 use ::tt::token_id as tt;
 
 use crate::{
-    adt::VariantData,
     builtin_type::BuiltinType,
+    data::adt::VariantData,
     item_tree::{
         Const, Enum, Function, Impl, ItemTreeId, ItemTreeNode, MacroDef, MacroRules, ModItem,
         Static, Struct, Trait, TraitAlias, TypeAlias, Union,
@@ -236,15 +233,15 @@ pub struct EnumVariantId {
     pub local_id: LocalEnumVariantId,
 }
 
-pub type LocalEnumVariantId = Idx<adt::EnumVariantData>;
+pub type LocalEnumVariantId = Idx<data::adt::EnumVariantData>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct FieldId {
     pub parent: VariantId,
     pub local_id: LocalFieldId,
 }
 
-pub type LocalFieldId = Idx<adt::FieldData>;
+pub type LocalFieldId = Idx<data::adt::FieldData>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);

crates/hir-def/src/expr.rs renamed to crates/hir-def/src/hir.rs

@@ -4,7 +4,8 @@ use hir_expand::{attrs::Attr, MacroCallId};
 use syntax::{ast, SmolStr};
 
 use crate::{
-    attr_macro_as_call_id, builtin_attr,
+    attr::builtin::{find_builtin_attr_idx, TOOL_MODULES},
+    attr_macro_as_call_id,
     db::DefDatabase,
     item_scope::BuiltinShadowMode,
     macro_id_to_def_id,
@@ -76,19 +77,15 @@ impl DefMap {
             let pred = |n: &_| *n == name;
 
             let registered = self.registered_tools.iter().map(SmolStr::as_str);
-            let is_tool = builtin_attr::TOOL_MODULES.iter().copied().chain(registered).any(pred);
+            let is_tool = TOOL_MODULES.iter().copied().chain(registered).any(pred);
             // FIXME: tool modules can be shadowed by actual modules
             if is_tool {
                 return true;
             }
 
             if segments.len() == 1 {
-                let registered = self.registered_attrs.iter().map(SmolStr::as_str);
-                let is_inert = builtin_attr::INERT_ATTRIBUTES
-                    .iter()
-                    .map(|it| it.name)
-                    .chain(registered)
-                    .any(pred);
+                let mut registered = self.registered_attrs.iter().map(SmolStr::as_str);
+                let is_inert = find_builtin_attr_idx(&name).is_some() || registered.any(pred);
                 return is_inert;
             }
         }

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

@@ -331,11 +331,11 @@ impl DefMap {
                         Some(local_id) => {
                             let variant = EnumVariantId { parent: e, local_id };
                             match &*enum_data.variants[local_id].variant_data {
-                                crate::adt::VariantData::Record(_) => {
+                                crate::data::adt::VariantData::Record(_) => {
                                     PerNs::types(variant.into(), Visibility::Public)
                                 }
-                                crate::adt::VariantData::Tuple(_)
-                                | crate::adt::VariantData::Unit => {
+                                crate::data::adt::VariantData::Tuple(_)
+                                | crate::data::adt::VariantData::Unit => {
                                     PerNs::both(variant.into(), variant.into(), Visibility::Public)
                                 }
                             }

crates/hir-def/src/lib.rs

@@ -12,8 +12,8 @@ use crate::{
     body::scope::{ExprScopes, ScopeId},
     builtin_type::BuiltinType,
     db::DefDatabase,
-    expr::{BindingId, ExprId, LabelId},
     generics::{GenericParams, TypeOrConstParamData},
+    hir::{BindingId, ExprId, LabelId},
     item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
     lang_item::LangItemTarget,
     nameres::DefMap,

crates/hir-def/src/macro_expansion_tests.rs renamed to crates/hir-def/src/macro_expansion_tests/mod.rs

@@ -9,7 +9,7 @@ use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
 
 use base_db::CrateId;
 use hir_def::{
-    expr::Movability,
+    hir::Movability,
     lang_item::{lang_attr, LangItem, LangItemTarget},
     AssocItemId, BlockId, GenericDefId, HasModule, ItemContainerId, Lookup, TypeAliasId,
 };
@@ -415,8 +415,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         let input_output = crate::make_type_and_const_binders(it, input_output);
 
         let movability = match self.db.body(parent)[expr] {
-            hir_def::expr::Expr::Closure {
-                closure_kind: hir_def::expr::ClosureKind::Generator(movability),
+            hir_def::hir::Expr::Closure {
+                closure_kind: hir_def::hir::ClosureKind::Generator(movability),
                 ..
             } => movability,
             _ => unreachable!("non generator expression interned as generator"),

crates/hir-def/src/nameres/attr_resolution.rs

@@ -3,7 +3,7 @@
 use base_db::CrateId;
 use chalk_ir::{BoundVar, DebruijnIndex, GenericArgData};
 use hir_def::{
-    expr::Expr,
+    hir::Expr,
     path::Path,
     resolver::{Resolver, ValueNs},
     type_ref::ConstRef,

crates/hir-def/src/nameres/path_resolution.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use base_db::{impl_intern_key, salsa, CrateId, Upcast};
 use hir_def::{
     db::DefDatabase,
-    expr::ExprId,
+    hir::ExprId,
     layout::{Layout, LayoutError, TargetDataLayout},
     AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId, GenericDefId,
     ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,

crates/hir-def/src/resolver.rs

@@ -16,8 +16,8 @@ use std::fmt;
 
 use base_db::CrateId;
 use hir_def::{
-    adt::VariantData,
-    expr::{Pat, PatId},
+    data::adt::VariantData,
+    hir::{Pat, PatId},
     src::HasSource,
     AdtId, AttrDefId, ConstId, EnumId, FunctionId, ItemContainerId, Lookup, ModuleDefId, StaticId,
     StructId,

crates/hir-ty/src/chalk_db.rs

@@ -27,7 +27,7 @@ use crate::{
 
 pub(crate) use hir_def::{
     body::Body,
-    expr::{Expr, ExprId, MatchArm, Pat, PatId},
+    hir::{Expr, ExprId, MatchArm, Pat, PatId},
     LocalFieldId, VariantId,
 };
 

crates/hir-ty/src/consteval.rs

@@ -1,6 +1,6 @@
 //! Validation of matches.
 //!
-//! This module provides lowering from [hir_def::expr::Pat] to [self::Pat] and match
+//! This module provides lowering from [hir_def::hir::Pat] to [self::Pat] and match
 //! checking algorithm.
 //!
 //! It is modeled on the rustc module `rustc_mir_build::thir::pattern`.
@@ -12,7 +12,7 @@ pub(crate) mod usefulness;
 
 use chalk_ir::Mutability;
 use hir_def::{
-    adt::VariantData, body::Body, expr::PatId, AdtId, EnumVariantId, LocalFieldId, VariantId,
+    body::Body, data::adt::VariantData, hir::PatId, AdtId, EnumVariantId, LocalFieldId, VariantId,
 };
 use hir_expand::name::Name;
 use stdx::{always, never};
@@ -125,15 +125,15 @@ impl<'a> PatCtxt<'a> {
         let variant = self.infer.variant_resolution_for_pat(pat);
 
         let kind = match self.body[pat] {
-            hir_def::expr::Pat::Wild => PatKind::Wild,
+            hir_def::hir::Pat::Wild => PatKind::Wild,
 
-            hir_def::expr::Pat::Lit(expr) => self.lower_lit(expr),
+            hir_def::hir::Pat::Lit(expr) => self.lower_lit(expr),
 
-            hir_def::expr::Pat::Path(ref path) => {
+            hir_def::hir::Pat::Path(ref path) => {
                 return self.lower_path(pat, path);
             }
 
-            hir_def::expr::Pat::Tuple { ref args, ellipsis } => {
+            hir_def::hir::Pat::Tuple { ref args, ellipsis } => {
                 let arity = match *ty.kind(Interner) {
                     TyKind::Tuple(arity, _) => arity,
                     _ => {
@@ -146,7 +146,7 @@ impl<'a> PatCtxt<'a> {
                 PatKind::Leaf { subpatterns }
             }
 
-            hir_def::expr::Pat::Bind { id, subpat, .. } => {
+            hir_def::hir::Pat::Bind { id, subpat, .. } => {
                 let bm = self.infer.pat_binding_modes[&pat];
                 let name = &self.body.bindings[id].name;
                 match (bm, ty.kind(Interner)) {
@@ -161,13 +161,13 @@ impl<'a> PatCtxt<'a> {
                 PatKind::Binding { name: name.clone(), subpattern: self.lower_opt_pattern(subpat) }
             }
 
-            hir_def::expr::Pat::TupleStruct { ref args, ellipsis, .. } if variant.is_some() => {
+            hir_def::hir::Pat::TupleStruct { ref args, ellipsis, .. } if variant.is_some() => {
                 let expected_len = variant.unwrap().variant_data(self.db.upcast()).fields().len();
                 let subpatterns = self.lower_tuple_subpats(args, expected_len, ellipsis);
                 self.lower_variant_or_leaf(pat, ty, subpatterns)
             }
 
-            hir_def::expr::Pat::Record { ref args, .. } if variant.is_some() => {
+            hir_def::hir::Pat::Record { ref args, .. } if variant.is_some() => {
                 let variant_data = variant.unwrap().variant_data(self.db.upcast());
                 let subpatterns = args
                     .iter()
@@ -187,12 +187,12 @@ impl<'a> PatCtxt<'a> {
                     }
                 }
             }
-            hir_def::expr::Pat::TupleStruct { .. } | hir_def::expr::Pat::Record { .. } => {
+            hir_def::hir::Pat::TupleStruct { .. } | hir_def::hir::Pat::Record { .. } => {
                 self.errors.push(PatternError::UnresolvedVariant);
                 PatKind::Wild
             }
 
-            hir_def::expr::Pat::Or(ref pats) => PatKind::Or { pats: self.lower_patterns(pats) },
+            hir_def::hir::Pat::Or(ref pats) => PatKind::Or { pats: self.lower_patterns(pats) },
 
             _ => {
                 self.errors.push(PatternError::Unimplemented);
@@ -279,8 +279,8 @@ impl<'a> PatCtxt<'a> {
         }
     }
 
-    fn lower_lit(&mut self, expr: hir_def::expr::ExprId) -> PatKind {
-        use hir_def::expr::{Expr, Literal::Bool};
+    fn lower_lit(&mut self, expr: hir_def::hir::ExprId) -> PatKind {
+        use hir_def::hir::{Expr, Literal::Bool};
 
         match self.body[expr] {
             Expr::Literal(Bool(value)) => PatKind::LiteralBool { value },