Fix jump to def link generation on primitive type associated methods

[GuillaumeGomez]

Fixes #156707.

Interestingly enough, the inference fails on primitive type, so instead I go around a bit by generating a PrimitiveType and then tweak a bit the href generation.

r? @fmease

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

[fmease]

Preliminary review

View changes since this review

[rustbot]

The GCC codegen subtree was changed

cc @antoyo

[fmease]

Could you use the normalized type for both the ADT check and the primitive one? So set ty to the normalized type? Something like the following (pseudo code):

let ty = tcx.type_of(def_id);
let ty =
    ...query_normalize(...ty...)
    .map(...resolve_vars_if_possible...)
    .unwrap_or(ty);

That's because I'm relatively sure we're currently failing at finding the definition if the impl contains free alias types (unlikely scenario but normalizing is simply the correct thing to do).

Consider:

• rustc a.rs --crate-type=lib:

  #![feature(lazy_type_alias, rustc_attrs)]
  #![rustc_coherence_is_core]
  
  type Identity<T> = T;
  
  impl Identity<u8> {
      pub fn inherent(self) {}
  }

• rustdoc b.rs -L. --generate-link-to-definition -Zunstable-options:

  fn scope() {
      extern crate a;
      0u8.inherent();
  }

So under your PR I presume inherent still 404s but please double-check that locally.

View changes since the review

[fmease]

Suggested change

	// If the parent is an impl of a primitive type, it'll fail because primitives aren't
	// ADT, so instead we use `type_of` to get the actual primitive type.

I mean we're also using type_of in the ADT case. It's just that we first check if it's an ADT then if it's a primitive if it's not the former.

View changes since the review

[fmease]

Suggested change

	let (fqp, shortty): (Vec<Symbol>, ItemType) = match prim {
	Some(prim) => (vec![crate_name, prim.as_sym()], ItemType::Primitive),
	None => {
	let relative = clean::inline::item_relative_path(tcx, def_id);
	(once(crate_name).chain(relative).collect(), ItemType::from_def_id(def_id, tcx))
	}
	};
	let mut fqp = vec![crate_name];
	let shortty = if let Some(prim) = prim {
	fqp.push(prim.as_sym());
	ItemType::Primitive
	} else {
	fqp.append(&mut clean::inline::item_relative_path(tcx, def_id));
	ItemType::from_def_id(def_id, tcx)
	};

View changes since the review

[fmease]

Then r=me, thanks!