resolve: Move kind to (Local,Extern)ModuleData

petrochenkov · petrochenkov · commit 9c3c4b984312 · 2026-05-09T22:17:45.000+03:00
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -9,9 +9,8 @@ use std::sync::Arc;
 
 use rustc_ast::visit::{self, AssocCtxt, Visitor, WalkItemKind};
 use rustc_ast::{
-    self as ast, AssocItem, AssocItemKind, Block, ConstItem, DUMMY_NODE_ID, Delegation, Fn,
-    ForeignItem, ForeignItemKind, Inline, Item, ItemKind, NodeId, StaticItem, StmtKind, TraitAlias,
-    TyAlias,
+    self as ast, AssocItem, AssocItemKind, Block, ConstItem, Delegation, Fn, ForeignItem,
+    ForeignItemKind, Inline, Item, ItemKind, NodeId, StaticItem, StmtKind, TraitAlias, TyAlias,
 };
 use rustc_attr_parsing::AttributeParser;
 use rustc_expand::base::{ResolverExpand, SyntaxExtension, SyntaxExtensionKind};
@@ -168,12 +167,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     let expn_id = self.cstore().expn_that_defined_untracked(self.tcx, def_id);
                     let module = self.new_extern_module(
                         parent,
-                        ModuleKind::Def(
-                            def_kind,
-                            def_id,
-                            DUMMY_NODE_ID,
-                            Some(self.tcx.item_name(def_id)),
-                        ),
+                        def_kind,
+                        def_id,
+                        self.tcx.item_name(def_id),
                         expn_id,
                         self.def_span(def_id),
                         // FIXME: Account for `#[no_implicit_prelude]` attributes.
@@ -253,7 +249,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         match vis.kind {
             ast::VisibilityKind::Public => Ok(Visibility::Public),
             ast::VisibilityKind::Inherited => {
-                Ok(match parent_scope.module.kind {
+                Ok(match parent_scope.module.expect_local().kind {
                     // Any inherited visibility resolved directly inside an enum or trait
                     // (i.e. variants, fields, and trait items) inherits from the visibility
                     // of the enum or trait.
@@ -350,7 +346,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     pub(crate) fn build_reduced_graph_external(&self, module: ExternModule<'ra>) {
-        let def_id = module.def_id();
+        let def_id = module.def_id;
         let children = self.tcx.module_children(def_id);
         for (i, child) in children.iter().enumerate() {
             self.build_reduced_graph_for_external_crate_res(child, module, i, None)
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -240,7 +240,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return self.report_conflict(ident, ns, new_binding, old_binding);
         }
 
-        let container = match old_binding.parent_module.unwrap().kind {
+        let container = match old_binding.parent_module.unwrap().expect_local().kind {
             // Avoid using TyCtxt::def_kind_descr in the resolver, because it
             // indirectly *calls* the resolver, and would cause a query cycle.
             ModuleKind::Def(kind, def_id, _, _) => kind.descr(def_id),
@@ -1757,15 +1757,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
                 return;
             }
-            if Some(parent_nearest) == scope.opt_def_id() {
+            if Some(parent_nearest) == scope.kind.opt_def_id() {
                 err.subdiagnostic(MacroDefinedLater { span: unused_ident.span });
                 err.subdiagnostic(MacroSuggMovePosition { span: ident.span, ident });
                 return;
             }
         }
 
         if ident.name == kw::Default
-            && let ModuleKind::Def(DefKind::Enum, def_id, _, _) = parent_scope.module.kind
+            && let ModuleKind::Def(DefKind::Enum, def_id, _, _) = parent_scope.module.kind()
         {
             let span = self.def_span(def_id);
             let source_map = self.tcx.sess.source_map();
@@ -1894,7 +1894,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 ident.name,
             );
             let sugg_span =
-                if let ModuleKind::Def(DefKind::Enum, id, _, _) = parent_scope.module.kind {
+                if let ModuleKind::Def(DefKind::Enum, id, _, _) = parent_scope.module.kind() {
                     let span = self.def_span(id);
                     if span.from_expansion() {
                         None
@@ -2607,7 +2607,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         let module = module.to_module();
                         current_module.is_ancestor_of(module) && current_module != module
                     })
-                    .flat_map(|(_, module)| module.kind.name()),
+                    .map(|(_, module)| module.name),
             )
             .filter(|c| !c.to_string().is_empty())
             .collect::<Vec<_>>();
@@ -2631,8 +2631,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ) -> (String, String, Option<Suggestion>) {
         let is_last = failed_segment_idx == path.len() - 1;
         let ns = if is_last { opt_ns.unwrap_or(TypeNS) } else { TypeNS };
-        let module_res = match module {
-            Some(ModuleOrUniformRoot::Module(module)) => module.res(),
+        let module_def_id = match module {
+            Some(ModuleOrUniformRoot::Module(module)) => module.opt_def_id(),
             _ => None,
         };
         let scope = match &path[..failed_segment_idx] {
@@ -2647,7 +2647,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         };
         let message = format!("cannot find `{ident}` in {scope}");
 
-        if module_res == self.graph_root.res() {
+        if module_def_id == Some(CRATE_DEF_ID.to_def_id()) {
             let is_mod = |res| matches!(res, Res::Def(DefKind::Mod, _));
             let mut candidates = self.lookup_import_candidates(ident, TypeNS, parent_scope, is_mod);
             candidates
@@ -3145,7 +3145,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         if !kinds.contains(MacroKinds::BANG) {
             return None;
         }
-        let module_name = crate_module.kind.name().unwrap_or(kw::Crate);
+        let module_name = crate_module.name().unwrap_or(kw::Crate);
         let import_snippet = match import.kind {
             ImportKind::Single { source, target, .. } if source != target => {
                 format!("{source} as {target}")
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -247,7 +247,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return Some((self.expn_def_scope(expn_id), None));
         }
 
-        if let ModuleKind::Block = module.kind {
+        if let ModuleKind::Block = module.kind() {
             return Some((module.parent().unwrap().nearest_item_scope(), None));
         }
 
@@ -643,24 +643,24 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     Err(ControlFlow::Break(..)) => return decl,
                 }
             }
-            Scope::ModuleGlobs(module, _) if !module.kind.is_local() => {
+            Scope::ModuleGlobs(Module::Extern(_), _) => {
                 // Fast path: external module decoding only creates non-glob declarations.
                 Err(Determined)
             }
-            Scope::ModuleGlobs(module, derive_fallback_lint_id) => {
+            Scope::ModuleGlobs(Module::Local(module), derive_fallback_lint_id) => {
                 let (adjusted_parent_scope, adjusted_finalize) = if matches!(
                     scope_set,
                     ScopeSet::Module(..) | ScopeSet::ModuleAndExternPrelude(..)
                 ) {
                     (parent_scope, finalize)
                 } else {
                     (
-                        &ParentScope { module, ..*parent_scope },
+                        &ParentScope { module: module.to_module(), ..*parent_scope },
                         finalize.map(|f| Finalize { used: Used::Scope, ..f }),
                     )
                 };
                 let binding = self.reborrow().resolve_ident_in_module_globs_unadjusted(
-                    module.expect_local(),
+                    module,
                     ident,
                     orig_ident_span,
                     ns,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
@@ -1846,7 +1846,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Since import resolution is finished, globs will not define any more names.
         *module.globs.borrow_mut(self) = Vec::new();
 
-        let Some(def_id) = module.opt_def_id() else { return };
+        let Some(def_id) = module.kind.opt_def_id() else { return };
 
         let mut children = Vec::new();
         let mut ambig_children = Vec::new();
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -1942,7 +1942,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                             && let Some(ty) = &self.diag_metadata.current_self_type
                             && Some(true) == self.diag_metadata.in_non_gat_assoc_type
                             && let crate::ModuleKind::Def(DefKind::Trait, trait_id, _, _) =
-                                module.kind
+                                module.kind()
                         {
                             if def_id_matches_path(
                                 self.r.tcx,
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -38,8 +38,8 @@ use crate::late::{
 };
 use crate::ty::fast_reject::SimplifiedType;
 use crate::{
-    Finalize, Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, PathSource, Res,
-    Resolver, ScopeSet, Segment, errors, path_names_to_string,
+    Finalize, Module, ModuleOrUniformRoot, ParentScope, PathResult, PathSource, Res, Resolver,
+    ScopeSet, Segment, errors, path_names_to_string,
 };
 
 /// A field or associated item from self type suggested in case of resolution failure.
@@ -1698,7 +1698,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             && let TyKind::Path(_, self_ty_path) = &self_ty.kind
             && let PathResult::Module(ModuleOrUniformRoot::Module(module)) =
                 self.resolve_path(&Segment::from_path(self_ty_path), Some(TypeNS), None, source)
-            && let ModuleKind::Def(DefKind::Trait, ..) = module.kind
+            && module.def_kind() == Some(DefKind::Trait)
             && trait_ref.path.span == span
             && let PathSource::Trait(_) = source
             && let Some(Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, _)) = res
@@ -3014,12 +3014,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     fn find_module(&self, def_id: DefId) -> Option<(Module<'ra>, ImportSuggestion)> {
         let mut result = None;
         let mut seen_modules = FxHashSet::default();
-        let root_did = self.r.graph_root.def_id();
-        let mut worklist = vec![(
-            self.r.graph_root.to_module(),
-            ThinVec::new(),
-            root_did.is_local() || !self.r.tcx.is_doc_hidden(root_did),
-        )];
+        let mut worklist = vec![(self.r.graph_root.to_module(), ThinVec::new(), true)];
 
         while let Some((in_module, path_segments, doc_visible)) = worklist.pop() {
             // abort if the module is already found
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs

Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {`
`247`	`247`	`return Some((self.expn_def_scope(expn_id), None));`
`248`	`248`	`}`
`249`	`249`
`250`		`- if let ModuleKind::Block = module.kind {`
	`250`	`+ if let ModuleKind::Block = module.kind() {`
`251`	`251`	`return Some((module.parent().unwrap().nearest_item_scope(), None));`
`252`	`252`	`}`
`253`	`253`
`@@ -643,24 +643,24 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {`
`643`	`643`	`Err(ControlFlow::Break(..)) => return decl,`
`644`	`644`	`}`
`645`	`645`	`}`
`646`		`- Scope::ModuleGlobs(module, _) if !module.kind.is_local() => {`
	`646`	`+ Scope::ModuleGlobs(Module::Extern(_), _) => {`
`647`	`647`	`// Fast path: external module decoding only creates non-glob declarations.`
`648`	`648`	`Err(Determined)`
`649`	`649`	`}`
`650`		`- Scope::ModuleGlobs(module, derive_fallback_lint_id) => {`
	`650`	`+ Scope::ModuleGlobs(Module::Local(module), derive_fallback_lint_id) => {`
`651`	`651`	`let (adjusted_parent_scope, adjusted_finalize) = if matches!(`
`652`	`652`	`scope_set,`
`653`	`653`	`ScopeSet::Module(..) \| ScopeSet::ModuleAndExternPrelude(..)`
`654`	`654`	`) {`
`655`	`655`	`(parent_scope, finalize)`
`656`	`656`	`} else {`
`657`	`657`	`(`
`658`		`- &ParentScope { module, ..*parent_scope },`
	`658`	`+ &ParentScope { module: module.to_module(), ..*parent_scope },`
`659`	`659`	`finalize.map(\|f\| Finalize { used: Used::Scope, ..f }),`
`660`	`660`	`)`
`661`	`661`	`};`
`662`	`662`	`let binding = self.reborrow().resolve_ident_in_module_globs_unadjusted(`
`663`		`- module.expect_local(),`
	`663`	`+ module,`
`664`	`664`	`ident,`
`665`	`665`	`orig_ident_span,`
`666`	`666`	`ns,`
Original file line number	Diff line number	Diff line change
`@@ -1942,7 +1942,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {`
`1942`	`1942`	`&& let Some(ty) = &self.diag_metadata.current_self_type`
`1943`	`1943`	`&& Some(true) == self.diag_metadata.in_non_gat_assoc_type`
`1944`	`1944`	`&& let crate::ModuleKind::Def(DefKind::Trait, trait_id, _, _) =`
`1945`		`- module.kind`
	`1945`	`+ module.kind()`
`1946`	`1946`	`{`
`1947`	`1947`	`if def_id_matches_path(`
`1948`	`1948`	`self.r.tcx,`