rustdoc: turn is_unnamable into a compiler query

Author: lolbinarycat

compiler/rustc_interface/src/passes.rs

@@ -879,6 +879,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     providers.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
     providers.early_lint_checks = early_lint_checks;
     providers.env_var_os = env_var_os;
+    providers.is_unnamable = crate::queries::is_unnamable;
     limits::provide(providers);
     proc_macro_decls::provide(providers);
     rustc_const_eval::provide(providers);

compiler/rustc_interface/src/queries.rs

@@ -107,3 +107,25 @@ impl Linker {
         codegen_backend.link(sess, codegen_results, self.metadata, &self.output_filenames)
     }
 }
+
+/// Checks if the given defid refers to an item that is unnamable, such as one defined in a const block.
+// defined here so it can't accidentally be used directly instead of through the query.
+pub(crate) fn is_unnamable(tcx: TyCtxt<'_>, did: rustc_hir::def_id::DefId) -> bool {
+    use rustc_hir::def::DefKind;
+    let mut cur_did = did;
+    while let Some(parent) = tcx.opt_parent(cur_did) {
+        match tcx.def_kind(parent) {
+            // items defined in these can be linked to, as long as they are visible
+            DefKind::Mod | DefKind::ForeignMod => cur_did = parent,
+            // items in impls can be linked to,
+            // as long as we can link to the item the impl is on.
+            // since associated traits are not yet a thing,
+            // it should not be possible to refer to an impl item if
+            // the base type is not namable.
+            DefKind::Impl { .. } => return false,
+            // everything else does not have docs generated for it
+            _ => return true,
+        }
+    }
+    return false;
+}

compiler/rustc_middle/src/query/mod.rs

@@ -1547,6 +1547,12 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    /// Checks if the given defid refers to an item that is unnamable, such as one defined in a const block.
+    /// Used by rustdoc
+    query is_unnamable(def_id: DefId) -> bool {
+        desc { |tcx| "checking if `{}` is unnamable", tcx.def_path_str(def_id) }
+    }
+
     query impl_parent(def_id: DefId) -> Option<DefId> {
         desc { |tcx| "computing specialization parent impl of `{}`", tcx.def_path_str(def_id) }
         separate_provide_extern

src/librustdoc/html/format.rs

@@ -481,26 +481,6 @@ fn generate_item_def_id_path(
     Ok((url_parts, shortty, fqp))
 }
 
-/// Checks if the given defid refers to an item that is unnamable, such as one defined in a const block.
-fn is_unnamable(tcx: TyCtxt<'_>, did: DefId) -> bool {
-    let mut cur_did = did;
-    while let Some(parent) = tcx.opt_parent(cur_did) {
-        match tcx.def_kind(parent) {
-            // items defined in these can be linked to, as long as they are visible
-            DefKind::Mod | DefKind::ForeignMod => cur_did = parent,
-            // items in impls can be linked to,
-            // as long as we can link to the item the impl is on.
-            // since associated traits are not a thing,
-            // it should not be possible to refer to an impl item if
-            // the base type is not namable.
-            DefKind::Impl { .. } => return false,
-            // everything else does not have docs generated for it
-            _ => return true,
-        }
-    }
-    return false;
-}
-
 fn to_module_fqp(shortty: ItemType, fqp: &[Symbol]) -> &[Symbol] {
     if shortty == ItemType::Module { fqp } else { &fqp[..fqp.len() - 1] }
 }
@@ -574,7 +554,7 @@ pub(crate) fn href_with_root_path(
         }
         _ => original_did,
     };
-    if is_unnamable(cx.tcx(), did) {
+    if cx.tcx().is_unnamable(did) {
         return Err(HrefError::UnnamableItem);
     }
     let cache = cx.cache();