Even more laziness and caching

Author: Urgau

compiler/rustc_lint/src/non_local_def.rs

@@ -65,26 +65,14 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
             return;
         }
 
-        if !matches!(item.kind, ItemKind::Impl(_) | ItemKind::Macro(_, _)) {
-            return;
-        }
-
-        let Some((_, parent_node)) = cx.tcx.hir().parent_owner_iter(item.hir_id()).next() else {
-            return;
+        let mut parent_node = {
+            let mut parent_node_cache = None;
+            move || {
+                *parent_node_cache.get_or_insert_with(|| {
+                    cx.tcx.hir().parent_owner_iter(item.hir_id()).next().unwrap().1
+                })
+            }
         };
-        let parent_is_anon_const = matches!(
-            parent_node,
-            OwnerNode::Item(Item {
-                ident: Ident { name: kw::Underscore, .. },
-                kind: ItemKind::Const(..),
-                ..
-            })
-        );
-
-        // Per RFC we (currently) ignore anon-const (`const _: Ty = ...`) in top-level module.
-        if self.body_depth == 1 && parent_is_anon_const {
-            return;
-        }
 
         let cargo_update = || {
             let oexpn = item.span.ctxt().outer_expn_data();
@@ -119,9 +107,21 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                 // If that's the case this means that this impl block declaration
                 // is using local items and so we don't lint on it.
 
-                // We also ignore anon-const in item by including the anon-const
-                // parent as well; and since it's quite uncommon, we use smallvec
-                // to avoid unnecessary heap allocations.
+                let mut parent_node_is_anon_const = {
+                    let mut parent_node_is_anon_const = None;
+                    move || {
+                        *parent_node_is_anon_const.get_or_insert_with(|| {
+                            matches!(
+                                parent_node(),
+                                OwnerNode::Item(Item {
+                                    ident: Ident { name: kw::Underscore, .. },
+                                    kind: ItemKind::Const(..),
+                                    ..
+                                })
+                            )
+                        })
+                    }
+                };
                 let mut local_parent = {
                     let mut local_parent_cache = None;
                     move || {
@@ -132,8 +132,9 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                 let mut extra_local_parent = {
                     let mut extra_parent_cache = None;
                     move |did| {
-                        *extra_parent_cache
-                            .get_or_insert_with(|| parent_is_anon_const.then(|| cx.tcx.parent(did)))
+                        *extra_parent_cache.get_or_insert_with(|| {
+                            parent_node_is_anon_const().then(|| cx.tcx.parent(did))
+                        })
                     }
                 };
 
@@ -184,8 +185,13 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                 // If none of them have a local parent (LOGICAL NOR) this means that
                 // this impl definition is a non-local definition and so we lint on it.
                 if !(self_ty_has_local_parent || of_trait_has_local_parent) {
+                    // Per RFC we (currently) ignore anon-const (`const _: Ty = ...`) in top-level module.
+                    if parent_node_is_anon_const() && self.body_depth == 1 {
+                        return;
+                    }
+
                     let const_anon = if self.body_depth == 1
-                        && let OwnerNode::Item(item) = parent_node
+                        && let OwnerNode::Item(item) = parent_node()
                         && let ItemKind::Const(ty, _, _) = item.kind
                         && let TyKind::Tup(&[]) = ty.kind
                     {
@@ -200,7 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                         NonLocalDefinitionsDiag::Impl {
                             depth: self.body_depth,
                             body_kind_descr: "?" /* FIXME: cx.tcx.def_kind_descr(parent_def_kind, parent) */,
-                            body_name: parent_node
+                            body_name: parent_node()
                                 .ident()
                                 .map(|s| s.name.to_ident_string())
                                 .unwrap_or_else(|| "<unnameable>".to_string()),
@@ -219,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                     NonLocalDefinitionsDiag::MacroRules {
                         depth: self.body_depth,
                         body_kind_descr: "?" /* FIXME: cx.tcx.def_kind_descr(parent_def_kind, parent) */,
-                        body_name: parent_node
+                        body_name: parent_node()
                             .ident()
                             .map(|s| s.name.to_ident_string())
                             .unwrap_or_else(|| "<unnameable>".to_string()),