Enable opaque_types_defined_by to lazily compute spans only in the error case.

oli-obk · oli-obk · commit a3ef5887102f · 2024-03-06T10:27:15.000Z
This significantly reduces the dependencies on HIR, and will hopefully lead to better caching
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -3605,6 +3605,10 @@ impl<'hir> Node<'hir> {
                 ImplItemKind::Type(ty) => Some(ty),
                 _ => None,
             },
+            Node::ForeignItem(it) => match it.kind {
+                ForeignItemKind::Static(ty, _) => Some(ty),
+                _ => None,
+            },
             _ => None,
         }
     }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -1066,8 +1066,12 @@ impl<'tcx> TypePrivacyVisitor<'tcx> {
 
 impl<'tcx> rustc_ty_utils::sig_types::SpannedTypeVisitor<'tcx> for TypePrivacyVisitor<'tcx> {
     type Result = ControlFlow<()>;
-    fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) -> Self::Result {
-        self.span = span;
+    fn visit(
+        &mut self,
+        get_span: impl Fn() -> Span,
+        value: impl TypeVisitable<TyCtxt<'tcx>>,
+    ) -> Self::Result {
+        self.span = get_span();
         value.visit_with(&mut self.skeleton())
     }
 }
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -167,7 +167,7 @@ impl<'tcx, 'a> OpaqueTypeCollector<'tcx, 'a> {
                     .instantiate_identity_iter_copied()
                 {
                     trace!(?pred);
-                    self.visit(span, pred);
+                    self.visit(|| span, pred);
                 }
             }
             Err(NotUniqueParam::NotParam(arg)) => {
@@ -189,9 +189,12 @@ impl<'tcx, 'a> OpaqueTypeCollector<'tcx, 'a> {
 }
 
 impl<'tcx> SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx, '_> {
-    #[instrument(skip(self), ret, level = "trace")]
-    fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) {
-        let get_span = || span;
+    #[instrument(skip(self, get_span), ret, level = "trace")]
+    fn visit(
+        &mut self,
+        get_span: impl Fn() -> Span,
+        value: impl TypeVisitable<TyCtxt<'tcx>>,
+    ) -> Self::Result {
         let mut nested = OpaqueTypeCollector {
             get_span: &get_span,
             tcx: self.tcx,
@@ -204,6 +207,8 @@ impl<'tcx> SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx, '_> {
         self.opaques = nested.opaques;
         self.seen = nested.seen;
     }
+
+    type Result = ();
 }
 
 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx, '_> {
@@ -283,7 +288,8 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx, '_> {
                         // would have to walk all generic parameters of an Adt, which can quickly
                         // degenerate into looking at an exponential number of types.
                         let ty = self.tcx.type_of(field.did).instantiate_identity();
-                        self.visit(self.tcx.def_span(field.did), ty);
+                        let tcx = self.tcx;
+                        self.visit(|| tcx.def_span(field.did), ty);
                     }
                 }
             }
diff --git a/compiler/rustc_ty_utils/src/sig_types.rs b/compiler/rustc_ty_utils/src/sig_types.rs
@@ -8,9 +8,13 @@ use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::Span;
 use rustc_type_ir::visit::TypeVisitable;
 
-pub trait SpannedTypeVisitor<'tcx> {
+pub trait SpannedTypeVisitor<'tcx>: Sized {
     type Result: VisitorResult = ();
-    fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) -> Self::Result;
+    fn visit(
+        &mut self,
+        get_span: impl Fn() -> Span,
+        value: impl TypeVisitable<TyCtxt<'tcx>>,
+    ) -> Self::Result;
 }
 
 pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
@@ -24,48 +28,61 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
         // Walk over the signature of the function
         DefKind::AssocFn | DefKind::Fn => {
             let ty_sig = tcx.fn_sig(item).instantiate_identity();
-            let hir_sig = tcx.hir_node_by_def_id(item).fn_decl().unwrap();
+            let hir_sig = || tcx.hir_node_by_def_id(item).fn_decl().unwrap();
             // Walk over the inputs and outputs manually in order to get good spans for them.
-            try_visit!(visitor.visit(hir_sig.output.span(), ty_sig.output()));
-            for (hir, ty) in hir_sig.inputs.iter().zip(ty_sig.inputs().iter()) {
-                try_visit!(visitor.visit(hir.span, ty.map_bound(|x| *x)));
+            try_visit!(visitor.visit(|| hir_sig().output.span(), ty_sig.output()));
+            for (hir, ty) in ty_sig.inputs().iter().enumerate() {
+                try_visit!(visitor.visit(|| hir_sig().inputs[hir].span, ty.map_bound(|x| *x)));
             }
             for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(||span, pred));
             }
         }
-        // Walk over the type behind the alias
-        DefKind::TyAlias {..} | DefKind::AssocTy |
-        // Walk over the type of the item
-        DefKind::Static(_) | DefKind::Const | DefKind::AssocConst | DefKind::AnonConst => {
+        DefKind::AssocTy => {
             if let Some(ty) = tcx.hir_node_by_def_id(item).ty() {
                 // Associated types in traits don't necessarily have a type that we can visit
-                try_visit!(visitor.visit(ty.span, tcx.type_of(item).instantiate_identity()));
+                try_visit!(visitor.visit(|| ty.span, tcx.type_of(item).instantiate_identity()));
+            }
+            for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
+                try_visit!(visitor.visit(|| span, pred));
+            }
+        }
+        // Walk over the type behind the alias
+        DefKind::TyAlias { .. } |
+        // Walk over the type of the item
+        DefKind::Static(_) | DefKind::Const | DefKind::AssocConst => {
+            let span = || tcx.hir_node_by_def_id(item).ty().unwrap().span;
+            try_visit!(visitor.visit(span, tcx.type_of(item).instantiate_identity()));
+
+            for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
+                try_visit!(visitor.visit(|| span, pred));
             }
+        }
+        DefKind::AnonConst => {
             for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(|| span, pred));
             }
         }
         DefKind::OpaqueTy => {
             for (pred, span) in tcx.explicit_item_bounds(item).instantiate_identity_iter_copied() {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(||span, pred));
             }
         }
         // Look at field types
         DefKind::Struct | DefKind::Union | DefKind::Enum => {
-            let span = tcx.def_ident_span(item).unwrap();
+            let span = || tcx.def_ident_span(item).unwrap();
             let ty = tcx.type_of(item).instantiate_identity();
             try_visit!(visitor.visit(span, ty));
             let ty::Adt(def, args) = ty.kind() else {
-                span_bug!(span, "invalid type for {kind:?}: {:#?}", ty.kind())
+                span_bug!(span(), "invalid type for {kind:?}: {:#?}", ty.kind())
             };
             for field in def.all_fields() {
-                let span = tcx.def_ident_span(field.did).unwrap();
+                let span = || tcx.def_ident_span(field.did).unwrap();
                 let ty = field.ty(tcx, args);
                 try_visit!(visitor.visit(span, ty));
             }
             for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(|| span, pred));
             }
         }
         // These are not part of a public API, they can only appear as hidden types, and there
@@ -74,25 +91,33 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
         DefKind::InlineConst | DefKind::Closure => {}
         DefKind::Impl { of_trait } => {
             if of_trait {
-                let span = tcx.hir_node_by_def_id(item).expect_item().expect_impl().of_trait.unwrap().path.span;
+                let span = || {
+                    tcx.hir_node_by_def_id(item)
+                        .expect_item()
+                        .expect_impl()
+                        .of_trait
+                        .unwrap()
+                        .path
+                        .span
+                };
                 let args = &tcx.impl_trait_ref(item).unwrap().instantiate_identity().args[1..];
                 try_visit!(visitor.visit(span, args));
             }
-            let span = match tcx.hir_node_by_def_id(item).ty() {
+            let span = || match tcx.hir_node_by_def_id(item).ty() {
                 Some(ty) => ty.span,
                 _ => tcx.def_span(item),
             };
             try_visit!(visitor.visit(span, tcx.type_of(item).instantiate_identity()));
             for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(|| span, pred));
             }
         }
         DefKind::TraitAlias | DefKind::Trait => {
             for (pred, span) in tcx.predicates_of(item).instantiate_identity(tcx) {
-                try_visit!(visitor.visit(span, pred));
+                try_visit!(visitor.visit(|| span, pred));
             }
         }
-        | DefKind::Variant
+        DefKind::Variant
         | DefKind::TyParam
         | DefKind::ConstParam
         | DefKind::Ctor(_, _)
@@ -104,7 +129,7 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
             )
         }
         // These don't have any types.
-        | DefKind::ExternCrate
+        DefKind::ExternCrate
         | DefKind::ForeignMod
         | DefKind::ForeignTy
         | DefKind::Macro(_)

Original file line number	Diff line number	Diff line change
`@@ -3605,6 +3605,10 @@ impl<'hir> Node<'hir> {`
`3605`	`3605`	`ImplItemKind::Type(ty) => Some(ty),`
`3606`	`3606`	`_ => None,`
`3607`	`3607`	`},`
	`3608`	`+ Node::ForeignItem(it) => match it.kind {`
	`3609`	`+ ForeignItemKind::Static(ty, _) => Some(ty),`
	`3610`	`+ _ => None,`
	`3611`	`+ },`
`3608`	`3612`	`_ => None,`
`3609`	`3613`	`}`
`3610`	`3614`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1066,8 +1066,12 @@ impl<'tcx> TypePrivacyVisitor<'tcx> {`
`1066`	`1066`
`1067`	`1067`	`impl<'tcx> rustc_ty_utils::sig_types::SpannedTypeVisitor<'tcx> for TypePrivacyVisitor<'tcx> {`
`1068`	`1068`	`type Result = ControlFlow<()>;`
`1069`		`- fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) -> Self::Result {`
`1070`		`- self.span = span;`
	`1069`	`+ fn visit(`
	`1070`	`+ &mut self,`
	`1071`	`+ get_span: impl Fn() -> Span,`
	`1072`	`+ value: impl TypeVisitable<TyCtxt<'tcx>>,`
	`1073`	`+ ) -> Self::Result {`
	`1074`	`+ self.span = get_span();`
`1071`	`1075`	`value.visit_with(&mut self.skeleton())`
`1072`	`1076`	`}`
`1073`	`1077`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ impl<'tcx, 'a> OpaqueTypeCollector<'tcx, 'a> {`
`167`	`167`	`.instantiate_identity_iter_copied()`
`168`	`168`	`{`
`169`	`169`	`trace!(?pred);`
`170`		`- self.visit(span, pred);`
	`170`	`+ self.visit(\|\| span, pred);`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`	`Err(NotUniqueParam::NotParam(arg)) => {`
`@@ -189,9 +189,12 @@ impl<'tcx, 'a> OpaqueTypeCollector<'tcx, 'a> {`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`impl<'tcx> SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx, '_> {`
`192`		`- #[instrument(skip(self), ret, level = "trace")]`
`193`		`- fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) {`
`194`		`- let get_span = \|\| span;`
	`192`	`+ #[instrument(skip(self, get_span), ret, level = "trace")]`
	`193`	`+ fn visit(`
	`194`	`+ &mut self,`
	`195`	`+ get_span: impl Fn() -> Span,`
	`196`	`+ value: impl TypeVisitable<TyCtxt<'tcx>>,`
	`197`	`+ ) -> Self::Result {`
`195`	`198`	`let mut nested = OpaqueTypeCollector {`
`196`	`199`	`get_span: &get_span,`
`197`	`200`	`tcx: self.tcx,`
`@@ -204,6 +207,8 @@ impl<'tcx> SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx, '_> {`
`204`	`207`	`self.opaques = nested.opaques;`
`205`	`208`	`self.seen = nested.seen;`
`206`	`209`	`}`
	`210`	`+`
	`211`	`+ type Result = ();`
`207`	`212`	`}`
`208`	`213`
`209`	`214`	`impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx, '_> {`
`@@ -283,7 +288,8 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx, '_> {`
`283`	`288`	`// would have to walk all generic parameters of an Adt, which can quickly`
`284`	`289`	`// degenerate into looking at an exponential number of types.`
`285`	`290`	`let ty = self.tcx.type_of(field.did).instantiate_identity();`
`286`		`- self.visit(self.tcx.def_span(field.did), ty);`
	`291`	`+ let tcx = self.tcx;`
	`292`	`+ self.visit(\|\| tcx.def_span(field.did), ty);`
`287`	`293`	`}`
`288`	`294`	`}`
`289`	`295`	`}`