rustdoc: rewrite the proc macro intra doc link fix entirly

I thought of an edge case that was impossible to
handle with the old impl, so I went ahead and
rewrote the whole thing to use a more robust solution.

Author: lolbinarycat

src/librustdoc/passes/collect_intra_doc_links.rs

@@ -22,7 +22,7 @@ use rustc_resolve::rustdoc::{
     MalformedGenerics, has_primitive_or_keyword_docs, prepare_to_doc_link_resolution,
     source_span_for_markdown_range, strip_generics_from_path,
 };
-use rustc_session::lint::Lint;
+use rustc_session::{lint::Lint, config::CrateType};
 use rustc_span::BytePos;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::symbol::{Ident, Symbol, sym};
@@ -1174,7 +1174,6 @@ impl LinkCollector<'_, '_> {
     #[allow(rustc::potential_query_instability)]
     pub(crate) fn resolve_ambiguities(&mut self) {
         let mut ambiguous_links = mem::take(&mut self.ambiguous_links);
-
         for ((item_id, path_str), info_items) in ambiguous_links.iter_mut() {
             for info in info_items {
                 info.resolved.retain(|(res, _)| match res {
@@ -2219,17 +2218,6 @@ fn report_malformed_generics(
     );
 }
 
-fn refer_to_single_item(v: &[Res]) -> bool {
-    // proc macros can exist in multiple namespaces at once,
-    // so we need to compare DefIds
-    v.iter()
-        .try_reduce(|l, r| match (l, r) {
-            (Res::Def(_, lid), Res::Def(_, rid)) if lid == rid => Some(l),
-            _ => None,
-        })
-        .is_some()
-}
-
 /// Report an ambiguity error, where there were multiple possible resolutions.
 ///
 /// If all `candidates` have the same kind, it's not possible to disambiguate so in this case,
@@ -2243,16 +2231,56 @@ fn ambiguity_error(
     emit_error: bool,
 ) -> bool {
     let mut descrs = FxHashSet::default();
-    let kinds = candidates
+	// proc macros can exist in multiple namespaces at once,
+    // so we need to compare DefIds to remove
+	// the candidite in the fn namespace
+	let mut possible_proc_macro_id = None;
+	let is_proc_macro_crate =
+		cx.tcx.crate_types() == &[CrateType::ProcMacro];
+    let mut kinds = candidates
         .iter()
         .map(
             |(res, def_id)| {
-                if let Some(def_id) = def_id { Res::from_def_id(cx.tcx, *def_id) } else { *res }
+                let r = if let Some(def_id) = def_id { Res::from_def_id(cx.tcx, *def_id) } else { *res };
+				if is_proc_macro_crate &&
+					let Res::Def(DefKind::Macro(_), id) = r
+				{
+					possible_proc_macro_id = Some(id);
+				}
+				r
             },
         )
-        .filter(|res| descrs.insert(res.descr()))
         .collect::<Vec<_>>();
-    if descrs.len() == 1 || refer_to_single_item(&kinds) {
+	// in order to properly dedup proc macros,
+	// we have to do it in two passes,
+	// completing the full traversal to find
+	// the possible duplicate in the macro namespace,
+	// then another full traversal to eliminate the
+	// candidite in the fn namespace.
+	// thus, we have to do an iteration after
+	// collection is finished.
+	//
+	// as an optimization, we only deduplicate if we're in a proc-macro crate,
+	// and only if we already found something that looks like a proc macro.
+	if is_proc_macro_crate &&
+		let Some(macro_id) = possible_proc_macro_id
+	{
+		kinds.retain(|res| {
+			if let Res::Def(DefKind::Fn, fn_id) = res &&
+				macro_id == *fn_id
+			{
+				false
+			} else {
+				true
+			}
+		});
+	}
+
+	kinds.retain(|res| {
+		descrs.insert(res.descr())
+	});
+
+    if descrs.len() == 1 {
         // There is no way for users to disambiguate at this point, so better return the first
         // candidate and not show a warning.
         return false;

tests/rustdoc-ui/intra-doc/bad-link-to-proc-macro.rs

@@ -0,0 +1,20 @@
+//@ compile-flags: --crate-type=proc-macro --document-private-items
+#![deny(rustdoc::broken_intra_doc_links)]
+
+//! Link to [`m`].
+//~^ ERROR `m` is both a module and a macro
+
+// test a further edge case related to https://github.com/rust-lang/rust/issues/91274
+
+// we need to make sure that when there is actually an ambiguity in a proc-macro crate, we print out a sensible error.
+// because proc macro crates can't normally export modules,
+// this can only happen in --document-private-items mode.
+
+extern crate proc_macro;
+
+mod m {}
+
+#[proc_macro]
+pub fn m(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    input
+}

tests/rustdoc-ui/intra-doc/bad-link-to-proc-macro.stderr

@@ -0,0 +1,22 @@
+error: `m` is both a module and a macro
+  --> $DIR/bad-link-to-proc-macro.rs:4:15
+   |
+LL | //! Link to [`m`].
+   |               ^ ambiguous link
+   |
+note: the lint level is defined here
+  --> $DIR/bad-link-to-proc-macro.rs:2:9
+   |
+LL | #![deny(rustdoc::broken_intra_doc_links)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: to link to the module, prefix with `mod@`
+   |
+LL | //! Link to [`mod@m`].
+   |               ++++
+help: to link to the macro, add an exclamation mark
+   |
+LL | //! Link to [`m!`].
+   |                +
+
+error: aborting due to 1 previous error
+