Cleanup

camelid · camelid · commit d04b5dde5e02 · 2024-08-15T14:52:59.000-07:00
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
@@ -9,16 +9,16 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_span::hygiene::LocalExpnId;
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::Span;
-use tracing::{debug, instrument};
+use tracing::debug;
 
-use crate::{ImplTraitContext, PendingAnonConstInfo, Resolver};
+use crate::{ImplTraitContext, InvocationParent, PendingAnonConstInfo, Resolver};
 
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,
     fragment: &AstFragment,
     expansion: LocalExpnId,
 ) {
-    let (parent_def, pending_anon_const_info, impl_trait_context, in_attr) =
+    let InvocationParent { parent_def, pending_anon_const_info, impl_trait_context, in_attr } =
         resolver.invocation_parents[&expansion];
     let mut visitor = DefCollector {
         resolver,
@@ -50,17 +50,6 @@ impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
         span: Span,
     ) -> LocalDefId {
         let parent_def = self.parent_def;
-        self.create_def_with_parent(parent_def, node_id, name, def_kind, span)
-    }
-
-    fn create_def_with_parent(
-        &mut self,
-        parent_def: LocalDefId,
-        node_id: NodeId,
-        name: Symbol,
-        def_kind: DefKind,
-        span: Span,
-    ) -> LocalDefId {
         debug!(
             "create_def(node_id={:?}, def_kind={:?}, parent_def={:?})",
             node_id, def_kind, parent_def
@@ -133,7 +122,12 @@ impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
         let pending_anon_const_info = self.pending_anon_const_info.take();
         let old_parent = self.resolver.invocation_parents.insert(
             id,
-            (self.parent_def, pending_anon_const_info, self.impl_trait_context, self.in_attr),
+            InvocationParent {
+                parent_def: self.parent_def,
+                pending_anon_const_info,
+                impl_trait_context: self.impl_trait_context,
+                in_attr: self.in_attr,
+            },
         );
         assert!(old_parent.is_none(), "parent `LocalDefId` is reset for an invocation");
     }
@@ -334,7 +328,6 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
         }
     }
 
-    #[instrument(level = "debug", skip(self))]
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
         // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
         // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
@@ -343,18 +336,12 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
         // items will be messed up, but that's ok because there can't be any if we're just looking
         // for bare idents.
         if matches!(constant.value.maybe_unwrap_block().kind, ExprKind::MacCall(..)) {
-            debug!("ATTN(strict): unwrapped const is macro");
-            self.pending_anon_const_info = Some(PendingAnonConstInfo {
-                parent_def: self.parent_def,
-                id: constant.id,
-                span: constant.value.span,
-            });
+            self.pending_anon_const_info =
+                Some(PendingAnonConstInfo { id: constant.id, span: constant.value.span });
             visit::walk_anon_const(self, constant)
         } else if constant.value.is_potential_trivial_const_arg() {
-            debug!("ATTN(strict): unwrapped const is potentially trivial");
             visit::walk_anon_const(self, constant)
         } else {
-            debug!("ATTN(strict): unwrapped const is not trivial");
             let def =
                 self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);
             self.with_parent(def, |this| visit::walk_anon_const(this, constant));
@@ -367,19 +354,10 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
         }
 
         let grandparent_def = if let Some(pending_anon) = self.pending_anon_const_info {
-            debug!("ATTN(lazy): pending anon={pending_anon:?} expr={expr:?}");
             self.pending_anon_const_info = None;
             if !expr.is_potential_trivial_const_arg() {
-                debug!("ATTN(lazy): pending anon is not trivial");
-                self.create_def_with_parent(
-                    pending_anon.parent_def,
-                    pending_anon.id,
-                    kw::Empty,
-                    DefKind::AnonConst,
-                    pending_anon.span,
-                )
+                self.create_def(pending_anon.id, kw::Empty, DefKind::AnonConst, pending_anon.span)
             } else {
-                debug!("ATTN(lazy): pending anon is potentially trivial");
                 self.parent_def
             }
         } else {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -171,8 +171,24 @@ impl<'a> ParentScope<'a> {
 }
 
 #[derive(Copy, Debug, Clone)]
-struct PendingAnonConstInfo {
+struct InvocationParent {
     parent_def: LocalDefId,
+    pending_anon_const_info: Option<PendingAnonConstInfo>,
+    impl_trait_context: ImplTraitContext,
+    in_attr: bool,
+}
+
+impl InvocationParent {
+    const ROOT: Self = Self {
+        parent_def: CRATE_DEF_ID,
+        pending_anon_const_info: None,
+        impl_trait_context: ImplTraitContext::Existential,
+        in_attr: false,
+    };
+}
+
+#[derive(Copy, Debug, Clone)]
+struct PendingAnonConstInfo {
     id: NodeId,
     span: Span,
 }
@@ -1150,10 +1166,7 @@ pub struct Resolver<'a, 'tcx> {
     /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
     /// we know what parent node that fragment should be attached to thanks to this table,
     /// and how the `impl Trait` fragments were introduced.
-    invocation_parents: FxHashMap<
-        LocalExpnId,
-        (LocalDefId, Option<PendingAnonConstInfo>, ImplTraitContext, bool /*in_attr*/),
-    >,
+    invocation_parents: FxHashMap<LocalExpnId, InvocationParent>,
 
     /// Some way to know that we are in a *trait* impl in `visit_assoc_item`.
     /// FIXME: Replace with a more general AST map (together with some other fields).
@@ -1390,8 +1403,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         node_id_to_def_id.insert(CRATE_NODE_ID, crate_feed);
 
         let mut invocation_parents = FxHashMap::default();
-        invocation_parents
-            .insert(LocalExpnId::ROOT, (CRATE_DEF_ID, None, ImplTraitContext::Existential, false));
+        invocation_parents.insert(LocalExpnId::ROOT, InvocationParent::ROOT);
 
         let mut extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'_>> = tcx
             .sess
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
@@ -42,9 +42,9 @@ use crate::errors::{
 use crate::imports::Import;
 use crate::Namespace::*;
 use crate::{
-    BindingKey, BuiltinMacroState, DeriveData, Determinacy, Finalize, MacroData, ModuleKind,
-    ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult, ResolutionError,
-    Resolver, ScopeSet, Segment, ToNameBinding, Used,
+    BindingKey, BuiltinMacroState, DeriveData, Determinacy, Finalize, InvocationParent, MacroData,
+    ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
+    ResolutionError, Resolver, ScopeSet, Segment, ToNameBinding, Used,
 };
 
 type Res = def::Res<NodeId>;
@@ -183,7 +183,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
     }
 
     fn invocation_parent(&self, id: LocalExpnId) -> LocalDefId {
-        self.invocation_parents[&id].0
+        self.invocation_parents[&id].parent_def
     }
 
     fn resolve_dollar_crates(&mut self) {
@@ -303,12 +303,12 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
             .invocation_parents
             .get(&invoc_id)
             .or_else(|| self.invocation_parents.get(&eager_expansion_root))
-            .filter(|&&(mod_def_id, _, _, in_attr)| {
+            .filter(|&&InvocationParent { parent_def: mod_def_id, in_attr, .. }| {
                 in_attr
                     && invoc.fragment_kind == AstFragmentKind::Expr
                     && self.tcx.def_kind(mod_def_id) == DefKind::Mod
             })
-            .map(|&(mod_def_id, ..)| mod_def_id);
+            .map(|&InvocationParent { parent_def: mod_def_id, .. }| mod_def_id);
         let (ext, res) = self.smart_resolve_macro_path(
             path,
             kind,
@@ -951,7 +951,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                         let node_id = self
                             .invocation_parents
                             .get(&parent_scope.expansion)
-                            .map_or(ast::CRATE_NODE_ID, |id| self.def_id_to_node_id[id.0]);
+                            .map_or(ast::CRATE_NODE_ID, |parent| {
+                                self.def_id_to_node_id[parent.parent_def]
+                            });
                         self.lint_buffer.buffer_lint(
                             LEGACY_DERIVE_HELPERS,
                             node_id,
